trunk/ldap/model/src/main/antlr/distinguishedName.g - directory-ldap-api - Git at Google

 header {
 /*
  *  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
  *
  *    http://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.name;

 import java.io.StringReader;
 import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;

 import org.apache.directory.api.ldap.model.exception.LdapInvalidDnException;
 import javax.naming.NameParser;
 import org.apache.directory.api.ldap.model.entry.StringValue;
 import org.apache.directory.api.ldap.model.entry.BinaryValue;
 import org.apache.directory.api.ldap.model.schema.parsers.ParserMonitor;
 import org.apache.directory.api.util.Strings;

 }

 /**
  * An antlr generated Dn lexer.
  *
  * @author <a href="mailto:dev@directory.apache.org">Apache Directory Project</a>
  */
 class AntlrDnLexer extends Lexer;

 options    {
     k = 3 ;
     exportVocab=AntlrDn ;
     charVocabulary = '\u0000'..'\uFFFE';
     caseSensitive = false ;
     defaultErrorHandler = false ;
 }

 COMMA : ',' ;
 EQUALS : '=' ;
 PLUS : '+' ;
 HYPHEN : '-' ;
 UNDERSCORE : '_' ;
 DQUOTE : '"' ;
 SEMI : ';' ;
 LANGLE : '<' ;
 RANGLE : '>' ;
 SPACE : ' ' ;

 NUMERICOID_OR_ALPHA_OR_DIGIT
     : ( NUMERICOID ) => NUMERICOID { $setType(NUMERICOID); }
     | ( DIGIT ) => DIGIT { $setType(DIGIT); }
     | ( ALPHA ) => ALPHA { $setType(ALPHA); }
     ;
 protected NUMERICOID : ( "oid." )? NUMBER ( DOT NUMBER )+ ;
 protected DOT: '.' ;
 protected NUMBER: DIGIT | ( LDIGIT ( DIGIT )+ ) ;
 protected LDIGIT : '1'..'9' ;
 protected DIGIT : '0'..'9' ;
 protected ALPHA : 'a'..'z' ;

 HEXPAIR_OR_ESCESC_ESCSHARP_OR_ESC
     : (ESC HEX HEX) => HEXPAIR { $setType(HEXPAIR); }
     | ESCESC { $setType(ESCESC); }
     | ESCSHARP { $setType(ESCSHARP); }
     | ESC { $setType(ESC); }
     ;
 protected HEXPAIR : ESC! HEX HEX ;
 protected ESC : '\\';
 protected ESCESC : ESC ESC;
 protected ESCSHARP : ESC SHARP;
 protected HEX: DIGIT | 'a'..'f' ;

 HEXVALUE_OR_SHARP
     : (SHARP ( HEX HEX )+) => HEXVALUE { $setType(HEXVALUE); }
     | SHARP { $setType(SHARP); }
     ;
 protected HEXVALUE : SHARP! ( HEX HEX )+ ;
 protected SHARP: '#' ;

 UTFMB : '\u0080'..'\uFFFE' ;

 /**
  * RFC 4514, Section 3:
  * LUTF1 = %x01-1F / %x21 / %x24-2A / %x2D-3A /
  *    %x3D / %x3F-5B / %x5D-7F
  *
  * To avoid nondeterminism the following
  * rules are excluded. These rules are
  * explicitly added in the productions.
  *   EQUALS (0x3D)
  *   HYPHEN (0x2D)
  *   UNDERSCORE (0x5F)
  *   DIGIT (0x30-0x39)
  *   ALPHA (0x41-0x5A and 0x61-0x7A)
  */
 LUTF1_REST :
     '\u0001'..'\u001F' |
     '\u0021' |
     '\u0024'..'\u002A' |
     '\u002E'..'\u002F' |
     '\u003A' |
     '\u003F'..'\u0040' |
     '\u005B' |
     '\u005D'..'\u005E' |
     '\u0060' |
     '\u007B'..'\u007F'
     ;


 /**
  * An antlr generated Dn parser.
  *
  * @author <a href="mailto:dev@directory.apache.org">Apache Directory Project</a>
  */
 class AntlrDnParser extends Parser;
 options    {
     k = 3 ;
     defaultErrorHandler = false ;
     //buildAST=true ;
 }

 {
     private ParserMonitor monitor = null;
     public void setParserMonitor( ParserMonitor monitor )
     {
         this.monitor = monitor;
     }
     private void matchedProduction( String msg )
     {
         if ( null != monitor )
         {
             monitor.matchedProduction( msg );
         }
     }
     static class UpAndNormValue
     {
         Object value = "";
         String rawValue = "";
 		int lastEscapedSpace = -1;
     }
 }

     /**
      * Parses an Dn string.
      *
      * RFC 4514, Section 3
      * distinguishedName = [ relativeDistinguishedName
      *     *( COMMA relativeDistinguishedName ) ]
      *
      * RFC 2253, Section 3
      * distinguishedName = [name]
      * name       = name-component *("," name-component)
      *
      * RFC 1779, Section 2.3
      * <name> ::= <name-component> ( <spaced-separator> )
      *        | <name-component> <spaced-separator> <name>
      * <spaced-separator> ::= <optional-space>
      *             <separator>
      *             <optional-space>
      * <separator> ::=  "," | ";"
      * <optional-space> ::= ( <CR> ) *( " " )
      *
      */
 distinguishedName [Dn dn]
     {
         matchedProduction( "distinguishedName()" );
         Rdn rdn = null;
     }
     :
     (
         rdn = relativeDistinguishedName[new Rdn()]
         {
             try
             {
                 dn.add( rdn );
             }
             catch ( LdapInvalidDnException lide )
             {
                 // Do nothing, can't get an exception here
             }

             rdn=null;
         }
         (
             ( COMMA | SEMI )
             rdn = relativeDistinguishedName[new Rdn()]
             {
                 try
                 {
                     dn.add( rdn );
                 }
                 catch ( LdapInvalidDnException lide )
                 {
                     // Do nothing, can't get an exception here
                 }

                 rdn=null;
             }
         )*
         EOF
     )?
     ;


     /**
      * Parses an Dn string.
      *
      * RFC 4514, Section 3
      * distinguishedName = [ relativeDistinguishedName
      *     *( COMMA relativeDistinguishedName ) ]
      *
      * RFC 2253, Section 3
      * distinguishedName = [name]
      * name       = name-component *("," name-component)
      *
      * RFC 1779, Section 2.3
      * <name> ::= <name-component> ( <spaced-separator> )
      *        | <name-component> <spaced-separator> <name>
      * <spaced-separator> ::= <optional-space>
      *             <separator>
      *             <optional-space>
      * <separator> ::=  "," | ";"
      * <optional-space> ::= ( <CR> ) *( " " )
      *
      */
 relativeDistinguishedNames [List<Rdn> rdns]
     {
         matchedProduction( "relativeDistinguishedNames()" );
         Rdn rdn = null;
     }
     :
     (
         rdn = relativeDistinguishedName[new Rdn()]
         {
             rdns.add( rdn );
         }
         (
             ( COMMA | SEMI )
             rdn = relativeDistinguishedName[new Rdn()]
             {
                 rdns.add( rdn );
             }
         )*
         EOF
     )?
     ;

     /**
      * Parses an Rdn string.
      *
      * RFC 4514, Section 3
      * relativeDistinguishedName = attributeTypeAndValue
      *     *( PLUS attributeTypeAndValue )
      *
      * RFC 2253, Section 3
      * name-component = attributeTypeAndValue *("+" attributeTypeAndValue)
      *
      * RFC 1779, Section 2.3
      * <name-component> ::= <attribute>
      *     | <attribute> <optional-space> "+"
      *       <optional-space> <name-component>
      *
      */
 relativeDistinguishedName [Rdn initialRdn] returns [Rdn rdn]
     {
         matchedProduction( "relativeDistinguishedName()" );
         rdn = initialRdn;
         String tmp;
         String upName = "";
     }
     :
     (
         tmp = attributeTypeAndValue[rdn]
         {
             upName += tmp;
         }
         (
             PLUS { upName += "+"; }
             tmp = attributeTypeAndValue[rdn]
             {
                 upName += tmp;
             }
         )*
     )
     {
         rdn.normalize();
         rdn.setUpName( upName );
     }
     ;


     /**
      * RFC 4514, Section 3
      * attributeTypeAndValue = attributeType EQUALS attributeValue
      *
      * RFC 2253, Section 3
      * attributeTypeAndValue = attributeType "=" attributeValue
      *
      */
 attributeTypeAndValue [Rdn rdn] returns [String upName = ""]
     {
         matchedProduction( "attributeTypeAndValue()" );
         String type = null;
         UpAndNormValue value = new UpAndNormValue();
         String upValue = null;
     }
     :
     (
         ( SPACE { upName += " "; } )*
         type = attributeType { upName += type; }
         ( SPACE { upName += " "; } )*
         EQUALS { upName += "="; }
         ( SPACE
         {
             upName += " ";

             if ( upValue == null )
             {
                 upValue = " ";
             }
             else
             {
                 upValue += " ";
             }
         } )*
         attributeValue[value]
         {
             try
             {
                 upName += value.rawValue;
                 Ava ava = null;

                 if ( value.value instanceof String )
                 {
                     if ( upValue != null )
                     {
                         value.rawValue = upValue + value.rawValue;
                     }

 					int start = 0;

 					for ( int pos = 0; pos < value.rawValue.length(); pos++ )
 					{
 					    if ( value.rawValue.charAt( pos ) == ' ' )
 					    {
 					        start++;
 					    }
 					    else
 					    {
 					        break;
 					    }
 					}

 					boolean escape = false;
 					int lastEscapedSpace = -1;

 					for ( int pos = start; pos< value.rawValue.length(); pos++ )
 					{
 					    if ( escape )
 					    {
 					        escape = false;

 					        if ( value.rawValue.charAt( pos ) == ' ' )
 					        {
 					            lastEscapedSpace = pos;
 					        }
 					    }
 					    else if ( value.rawValue.charAt( pos ) == '\\' )
 					    {
 					        escape = true;
 					    }
 					}

 					// Remove spaces from the right if needed
 					int pos = value.rawValue.length() - 1;

 					while ( ( value.rawValue.charAt( pos ) == ' ' ) && ( pos > lastEscapedSpace ) )
 					{
 					    pos--;
 					}

 					String trimmedValue = value.rawValue;

 					if ( ( start > 0 ) || ( pos + 1 < value.rawValue.length() ) )
 					{
 						trimmedValue = value.rawValue.substring( start, pos + 1 );
 					}

 					Object unescapedValue = Rdn.unescapeValue( trimmedValue );

                     if ( unescapedValue instanceof String )
                     {
                         ava = new Ava(
                             type,
                             type,
                             new StringValue( trimmedValue, (String)unescapedValue ),
                             upName
                         );
                     }
                     else
                     {
                         ava = new Ava(
                             type,
                             type,
                             new BinaryValue( (byte[])unescapedValue ),
                             upName
                         );
                     }
                 }
                 else
                 {
                     ava = new Ava(
                         type,
                         type,
                         new BinaryValue( (byte[])value.value ),
                         upName
                     );
                 }

                 rdn.addAVA( null, ava );
             }
             catch ( LdapInvalidDnException e )
             {
                 throw new SemanticException( e.getMessage() );
             }
         }
     )
     ;


     /**
      * RFC 4514 Section 3
      *
      * attributeType = descr / numericoid
      *
      */
 attributeType returns [String attributeType]
     {
         matchedProduction( "attributeType()" );
     }
     :
     (
         attributeType = descr
         |
         attributeType = numericoid
     )
     ;


     /**
      * RFC 4512 Section 1.4
      *
      * descr = keystring
      * keystring = leadkeychar *keychar
      * leadkeychar = ALPHA
      * keychar = ALPHA / DIGIT / HYPHEN
      *
      * We additionally add UNDERSCORE because some servers allow them.
      *
      */
 descr returns [String descr]
     {
         matchedProduction( "descr()" );
     }
     :
     leadkeychar:ALPHA { descr = leadkeychar.getText(); }
     (
         alpha:ALPHA { descr += alpha.getText(); }
         |
         digit:DIGIT { descr += digit.getText(); }
         |
         hyphen:HYPHEN { descr += hyphen.getText(); }
         |
         underscore:UNDERSCORE { descr += underscore.getText(); }
     )*
     ;


     /**
      * RFC 4512 Section 1.4
      *
      * numericoid = number 1*( DOT number )
      * number  = DIGIT / ( LDIGIT 1*DIGIT )
      * DIGIT   = %x30 / LDIGIT       ; "0"-"9"
      * LDIGIT  = %x31-39             ; "1"-"9"
      *
      */
 numericoid returns [String numericoid = ""]
     {
         matchedProduction( "numericoid()" );
     }
     :
     noid:NUMERICOID { numericoid += noid.getText(); }
     ;


     /**
      * RFC 4514, Section 3
      * attributeValue = string / hexstring
      *
      * RFC 2253, Section 3
      * attributeValue = string
      * string     = *( stringchar / pair )
      *              / "#" hexstring
      *              / QUOTATION *( quotechar / pair ) QUOTATION ; only from v2
      *
      */
 attributeValue [UpAndNormValue value]
     {
         matchedProduction( "attributeValue()" );
     }
     :
     (
         (
             quotestring [value]
             ( SPACE { value.rawValue += " "; } )*
         )
         |
         string [value]
         |
         (
             hexstring [value]
             ( SPACE { value.rawValue += " "; } )*
         )
     )?
     ;


     /**
      * RFC 2253, Section 3
      *              / QUOTATION *( quotechar / pair ) QUOTATION ; only from v2
      * quotechar     = <any character except "\" or QUOTATION >
      *
      */
 quotestring [UpAndNormValue value]
     {
         matchedProduction( "quotestring()" );
         org.apache.directory.api.util.ByteBuffer bb = new org.apache.directory.api.util.ByteBuffer();
         byte[] bytes;
     }
     :
     (
         dq1:DQUOTE { value.rawValue += dq1.getText(); }
         (
             (
                 s:~(DQUOTE|ESC|ESCESC|ESCSHARP|HEXPAIR)
                 {
                     value.rawValue += s.getText();
                     bb.append( Strings.getBytesUtf8( s.getText() ) );
                 }
             )
             |
             bytes = pair[value] { bb.append( bytes ); }
         )*
         dq2:DQUOTE { value.rawValue += dq2.getText(); }
     )
     {
         String string = Strings.utf8ToString( bb.copyOfUsedBytes() );
         value.value = string;
     }
     ;


     /**
      * RFC 4514 Section 3
      *
      * hexstring = SHARP 1*hexpair
      *
      * If in <hexstring> form, a BER representation can be obtained from
      * converting each <hexpair> of the <hexstring> to the octet indicated
      * by the <hexpair>.
      *
      */
 hexstring [UpAndNormValue value]
     {
         matchedProduction( "hexstring()" );
     }
     :
     hexValue:HEXVALUE
     {
         // convert to byte[]
         value.rawValue = "#" + hexValue.getText();
         value.value = Strings.toByteArray( hexValue.getText() );
     }
     ;


     /**
      * RFC 4514 Section 3
      *
      * ; The following characters are to be escaped when they appear
      * ; in the value to be encoded: ESC, one of <escaped>, leading
      * ; SHARP or SPACE, trailing SPACE, and NULL.
      * string =   [ ( leadchar / pair ) [ *( stringchar / pair )
      *    ( trailchar / pair ) ] ]
      *
      */
 string [UpAndNormValue value]
     {
         matchedProduction( "string()" );
         org.apache.directory.api.util.ByteBuffer bb = new org.apache.directory.api.util.ByteBuffer();
         String tmp;
         byte[] bytes;
     }
     :
     (
         (
             tmp = lutf1
             {
                 value.rawValue += tmp;
                 bb.append( Strings.getBytesUtf8( tmp ) );
             }
             |
             tmp = utfmb
             {
                 value.rawValue += tmp;
                 bb.append( Strings.getBytesUtf8( tmp ) );
             }
             |
             bytes = pair [value]
 			{
 				bb.append( bytes );
 			}
         )
         (
             tmp = sutf1
             {
                 value.rawValue += tmp;
                 bb.append( Strings.getBytesUtf8( tmp ) );
             }
             |
             tmp = utfmb
             {
                 value.rawValue += tmp;
                 bb.append( Strings.getBytesUtf8( tmp ) );
             }
             |
             bytes = pair [value]
 			{
 				bb.append( bytes );
 			}
         )*
     )
     {
 		/*
         String string = Strings.utf8ToString( bb.copyOfUsedBytes() );

         // trim trailing space characters manually
         // don't know how to tell antlr that the last char mustn't be a space.
         int rawIndex = value.rawValue.length();
         while ( string.length() > 0 && rawIndex > 1
             && value.rawValue.charAt( rawIndex - 1 ) == ' '
             && value.rawValue.charAt( rawIndex - 2 ) != '\\' )
         {
             string = string.substring( 0, string.length() - 1 );
             rawIndex--;
         }

         value.value = string;
 		*/
     }
     ;


 /**
  * RFC 4514, Section 3:
  * LUTF1 = %x01-1F / %x21 / %x24-2A / %x2D-3A /
  *    %x3D / %x3F-5B / %x5D-7F
  *
  * The rule LUTF1_REST doesn't contain the following charcters,
  * so we must check them additionally
  *   EQUALS (0x3D)
  *   HYPHEN (0x2D)
  *   UNDERSCORE (0x5F)
  *   DIGIT (0x30-0x39)
  *   ALPHA (0x41-0x5A and 0x61-0x7A)
  */
 lutf1 returns [String lutf1=""]
     {
         matchedProduction( "lutf1()" );
     }
     :
     rest:LUTF1_REST { lutf1 = rest.getText(); }
     |
     equals:EQUALS { lutf1 = equals.getText(); }
     |
     hyphen:HYPHEN { lutf1 = hyphen.getText(); }
     |
     underscore:UNDERSCORE { lutf1 = underscore.getText(); }
     |
     digit:DIGIT { lutf1 = digit.getText(); }
     |
     alpha:ALPHA { lutf1 = alpha.getText(); }
     |
     numericoid:NUMERICOID  { lutf1 = numericoid.getText(); }
     ;

 /**
  * RFC 4514, Section 3:
  * SUTF1 = %x01-21 / %x23-2A / %x2D-3A /
  *    %x3D / %x3F-5B / %x5D-7F
  *
  * The rule LUTF1_REST doesn't contain the following charcters,
  * so we must check them additionally
  *   EQUALS (0x3D)
  *   HYPHEN (0x2D)
  *   UNDERSCORE (0x5F)
  *   DIGIT (0x30-0x39)
  *   ALPHA (0x41-0x5A and 0x61-0x7A)
  *   SHARP
  *   SPACE
  */
 sutf1 returns [String sutf1=""]
     {
         matchedProduction( "sutf1()" );
     }
     :
     rest:LUTF1_REST { sutf1 = rest.getText(); }
     |
     equals:EQUALS { sutf1 = equals.getText(); }
     |
     hyphen:HYPHEN { sutf1 = hyphen.getText(); }
     |
     underscore:UNDERSCORE { sutf1 = underscore.getText(); }
     |
     digit:DIGIT { sutf1 = digit.getText(); }
     |
     alpha:ALPHA { sutf1 = alpha.getText(); }
     |
     sharp:SHARP { sutf1 = sharp.getText(); }
     |
     space:SPACE  { sutf1 = space.getText(); }
     |
     // This is a hack to deal with #NN included into the value, due to
     // some collision with the HEXVALUE token. In this case, we should
     // consider that a hex value is in fact a String
     hex:HEXVALUE { sutf1 = "#" + hex.getText(); }
     |
     numericoid:NUMERICOID  { sutf1 = numericoid.getText(); }
     ;


 utfmb returns [String utfmb]
     {
         matchedProduction( "utfmb()" );
     }
     :
     s:UTFMB { utfmb = s.getText(); }
     ;


     /**
      * RFC 4514, Section 3
      * pair = ESC ( ESC / special / hexpair )
      * special = escaped / SPACE / SHARP / EQUALS
      * escaped = DQUOTE / PLUS / COMMA / SEMI / LANGLE / RANGLE
      * hexpair = HEX HEX
      *
      * If in <string> form, a LDAP string representation asserted value can
      * be obtained by replacing (left to right, non-recursively) each <pair>
      * appearing in the <string> as follows:
      *   replace <ESC><ESC> with <ESC>;
      *   replace <ESC><special> with <special>;
      *   replace <ESC><hexpair> with the octet indicated by the <hexpair>.
      *
      * RFC 2253, Section 3
      * pair       = "\" ( special / "\" / QUOTATION / hexpair )
      * special    = "," / "=" / "+" / "<" /  ">" / "#" / ";"
      *
      * RFC 1779, Section 2.3
      * <pair> ::= "\" ( <special> | "\" | '"')
      * <special> ::= "," | "=" | <CR> | "+" | "<" |  ">"
      *           | "#" | ";"
      *
      */
 pair [UpAndNormValue value] returns [byte[] pair]
     {
         matchedProduction( "pair()" );
         String tmp;
     }
     :
     (
         ESCESC
         {
             value.rawValue += "\\\\";
             pair = Strings.getBytesUtf8( "\\" );
         }
     )
     |
     (
         ESCSHARP
         {
             value.rawValue += "\\#";
             pair = Strings.getBytesUtf8( "#" );
         }
     )
     |
     (
         ESC
         tmp = special
         {
             value.rawValue += "\\" + tmp;
             pair = Strings.getBytesUtf8( tmp );
         }
     )
     |
     (
         hexpair:HEXPAIR
         {
             value.rawValue += "\\" + hexpair.getText();
             pair = Strings.toByteArray( hexpair.getText() );
         }
     )
     ;


     /**
      * RFC 4514 Section 3
      *
      * special = escaped / SPACE / SHARP / EQUALS
      * escaped = DQUOTE / PLUS / COMMA / SEMI / LANGLE / RANGLE
      *
      */
 special returns [String special]
     {
         matchedProduction( "special()" );
     }
     :
     (
         dquote:DQUOTE { special = dquote.getText(); }
         |
         plus:PLUS { special = plus.getText(); }
         |
         comma:COMMA { special = comma.getText(); }
         |
         semi:SEMI { special = semi.getText(); }
         |
         langle:LANGLE { special = langle.getText(); }
         |
         rangle:RANGLE { special = rangle.getText(); }
         |
         space:SPACE { special = space.getText(); }
         |
         sharp:SHARP { special = sharp.getText(); }
         |
         equals:EQUALS { special = equals.getText(); }
     )
     ;
	header {
	/*
	* 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
	*
	* http://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.name;

	import java.io.StringReader;
	import java.util.ArrayList;
	import java.util.HashMap;
	import java.util.List;
	import java.util.Map;

	import org.apache.directory.api.ldap.model.exception.LdapInvalidDnException;
	import javax.naming.NameParser;
	import org.apache.directory.api.ldap.model.entry.StringValue;
	import org.apache.directory.api.ldap.model.entry.BinaryValue;
	import org.apache.directory.api.ldap.model.schema.parsers.ParserMonitor;
	import org.apache.directory.api.util.Strings;

	}

	/**
	* An antlr generated Dn lexer.
	*
	* @author <a href="mailto:dev@directory.apache.org">Apache Directory Project</a>
	*/
	class AntlrDnLexer extends Lexer;

	options {
	k = 3 ;
	exportVocab=AntlrDn ;
	charVocabulary = '\u0000'..'\uFFFE';
	caseSensitive = false ;
	defaultErrorHandler = false ;
	}

	COMMA : ',' ;
	EQUALS : '=' ;
	PLUS : '+' ;
	HYPHEN : '-' ;
	UNDERSCORE : '_' ;
	DQUOTE : '"' ;
	SEMI : ';' ;
	LANGLE : '<' ;
	RANGLE : '>' ;
	SPACE : ' ' ;

	NUMERICOID_OR_ALPHA_OR_DIGIT
	: ( NUMERICOID ) => NUMERICOID { $setType(NUMERICOID); }
	\| ( DIGIT ) => DIGIT { $setType(DIGIT); }
	\| ( ALPHA ) => ALPHA { $setType(ALPHA); }
	;
	protected NUMERICOID : ( "oid." )? NUMBER ( DOT NUMBER )+ ;
	protected DOT: '.' ;
	protected NUMBER: DIGIT \| ( LDIGIT ( DIGIT )+ ) ;
	protected LDIGIT : '1'..'9' ;
	protected DIGIT : '0'..'9' ;
	protected ALPHA : 'a'..'z' ;

	HEXPAIR_OR_ESCESC_ESCSHARP_OR_ESC
	: (ESC HEX HEX) => HEXPAIR { $setType(HEXPAIR); }
	\| ESCESC { $setType(ESCESC); }
	\| ESCSHARP { $setType(ESCSHARP); }
	\| ESC { $setType(ESC); }
	;
	protected HEXPAIR : ESC! HEX HEX ;
	protected ESC : '\\';
	protected ESCESC : ESC ESC;
	protected ESCSHARP : ESC SHARP;
	protected HEX: DIGIT \| 'a'..'f' ;

	HEXVALUE_OR_SHARP
	: (SHARP ( HEX HEX )+) => HEXVALUE { $setType(HEXVALUE); }
	\| SHARP { $setType(SHARP); }
	;
	protected HEXVALUE : SHARP! ( HEX HEX )+ ;
	protected SHARP: '#' ;

	UTFMB : '\u0080'..'\uFFFE' ;

	/**
	* RFC 4514, Section 3:
	* LUTF1 = %x01-1F / %x21 / %x24-2A / %x2D-3A /
	* %x3D / %x3F-5B / %x5D-7F
	*
	* To avoid nondeterminism the following
	* rules are excluded. These rules are
	* explicitly added in the productions.
	* EQUALS (0x3D)
	* HYPHEN (0x2D)
	* UNDERSCORE (0x5F)
	* DIGIT (0x30-0x39)
	* ALPHA (0x41-0x5A and 0x61-0x7A)
	*/
	LUTF1_REST :
	'\u0001'..'\u001F' \|
	'\u0021' \|
	'\u0024'..'\u002A' \|
	'\u002E'..'\u002F' \|
	'\u003A' \|
	'\u003F'..'\u0040' \|
	'\u005B' \|
	'\u005D'..'\u005E' \|
	'\u0060' \|
	'\u007B'..'\u007F'
	;


	/**
	* An antlr generated Dn parser.
	*
	* @author <a href="mailto:dev@directory.apache.org">Apache Directory Project</a>
	*/
	class AntlrDnParser extends Parser;
	options {
	k = 3 ;
	defaultErrorHandler = false ;
	//buildAST=true ;
	}

	{
	private ParserMonitor monitor = null;
	public void setParserMonitor( ParserMonitor monitor )
	{
	this.monitor = monitor;
	}
	private void matchedProduction( String msg )
	{
	if ( null != monitor )
	{
	monitor.matchedProduction( msg );
	}
	}
	static class UpAndNormValue
	{
	Object value = "";
	String rawValue = "";
	int lastEscapedSpace = -1;
	}
	}

	/**
	* Parses an Dn string.
	*
	* RFC 4514, Section 3
	* distinguishedName = [ relativeDistinguishedName
	* *( COMMA relativeDistinguishedName ) ]
	*
	* RFC 2253, Section 3
	* distinguishedName = [name]
	* name = name-component *("," name-component)
	*
	* RFC 1779, Section 2.3
	* <name> ::= <name-component> ( <spaced-separator> )
	* \| <name-component> <spaced-separator> <name>
	* <spaced-separator> ::= <optional-space>
	* <separator>
	* <optional-space>
	* <separator> ::= "," \| ";"
	* <optional-space> ::= ( <CR> ) *( " " )
	*
	*/
	distinguishedName [Dn dn]
	{
	matchedProduction( "distinguishedName()" );
	Rdn rdn = null;
	}
	:
	(
	rdn = relativeDistinguishedName[new Rdn()]
	{
	try
	{
	dn.add( rdn );
	}
	catch ( LdapInvalidDnException lide )
	{
	// Do nothing, can't get an exception here
	}

	rdn=null;
	}
	(
	( COMMA \| SEMI )
	rdn = relativeDistinguishedName[new Rdn()]
	{
	try
	{
	dn.add( rdn );
	}
	catch ( LdapInvalidDnException lide )
	{
	// Do nothing, can't get an exception here
	}

	rdn=null;
	}
	)*
	EOF
	)?
	;


	/**
	* Parses an Dn string.
	*
	* RFC 4514, Section 3
	* distinguishedName = [ relativeDistinguishedName
	* *( COMMA relativeDistinguishedName ) ]
	*
	* RFC 2253, Section 3
	* distinguishedName = [name]
	* name = name-component *("," name-component)
	*
	* RFC 1779, Section 2.3
	* <name> ::= <name-component> ( <spaced-separator> )
	* \| <name-component> <spaced-separator> <name>
	* <spaced-separator> ::= <optional-space>
	* <separator>
	* <optional-space>
	* <separator> ::= "," \| ";"
	* <optional-space> ::= ( <CR> ) *( " " )
	*
	*/
	relativeDistinguishedNames [List<Rdn> rdns]
	{
	matchedProduction( "relativeDistinguishedNames()" );
	Rdn rdn = null;
	}
	:
	(
	rdn = relativeDistinguishedName[new Rdn()]
	{
	rdns.add( rdn );
	}
	(
	( COMMA \| SEMI )
	rdn = relativeDistinguishedName[new Rdn()]
	{
	rdns.add( rdn );
	}
	)*
	EOF
	)?
	;

	/**
	* Parses an Rdn string.
	*
	* RFC 4514, Section 3
	* relativeDistinguishedName = attributeTypeAndValue
	* *( PLUS attributeTypeAndValue )
	*
	* RFC 2253, Section 3
	* name-component = attributeTypeAndValue *("+" attributeTypeAndValue)
	*
	* RFC 1779, Section 2.3
	* <name-component> ::= <attribute>
	* \| <attribute> <optional-space> "+"
	* <optional-space> <name-component>
	*
	*/
	relativeDistinguishedName [Rdn initialRdn] returns [Rdn rdn]
	{
	matchedProduction( "relativeDistinguishedName()" );
	rdn = initialRdn;
	String tmp;
	String upName = "";
	}
	:
	(
	tmp = attributeTypeAndValue[rdn]
	{
	upName += tmp;
	}
	(
	PLUS { upName += "+"; }
	tmp = attributeTypeAndValue[rdn]
	{
	upName += tmp;
	}
	)*
	)
	{
	rdn.normalize();
	rdn.setUpName( upName );
	}
	;


	/**
	* RFC 4514, Section 3
	* attributeTypeAndValue = attributeType EQUALS attributeValue
	*
	* RFC 2253, Section 3
	* attributeTypeAndValue = attributeType "=" attributeValue
	*
	*/
	attributeTypeAndValue [Rdn rdn] returns [String upName = ""]
	{
	matchedProduction( "attributeTypeAndValue()" );
	String type = null;
	UpAndNormValue value = new UpAndNormValue();
	String upValue = null;
	}
	:
	(
	( SPACE { upName += " "; } )*
	type = attributeType { upName += type; }
	( SPACE { upName += " "; } )*
	EQUALS { upName += "="; }
	( SPACE
	{
	upName += " ";

	if ( upValue == null )
	{
	upValue = " ";
	}
	else
	{
	upValue += " ";
	}
	} )*
	attributeValue[value]
	{
	try
	{
	upName += value.rawValue;
	Ava ava = null;

	if ( value.value instanceof String )
	{
	if ( upValue != null )
	{
	value.rawValue = upValue + value.rawValue;
	}

	int start = 0;

	for ( int pos = 0; pos < value.rawValue.length(); pos++ )
	{
	if ( value.rawValue.charAt( pos ) == ' ' )
	{
	start++;
	}
	else
	{
	break;
	}
	}

	boolean escape = false;
	int lastEscapedSpace = -1;

	for ( int pos = start; pos< value.rawValue.length(); pos++ )
	{
	if ( escape )
	{
	escape = false;

	if ( value.rawValue.charAt( pos ) == ' ' )
	{
	lastEscapedSpace = pos;
	}
	}
	else if ( value.rawValue.charAt( pos ) == '\\' )
	{
	escape = true;
	}
	}

	// Remove spaces from the right if needed
	int pos = value.rawValue.length() - 1;

	while ( ( value.rawValue.charAt( pos ) == ' ' ) && ( pos > lastEscapedSpace ) )
	{
	pos--;
	}

	String trimmedValue = value.rawValue;

	if ( ( start > 0 ) \|\| ( pos + 1 < value.rawValue.length() ) )
	{
	trimmedValue = value.rawValue.substring( start, pos + 1 );
	}

	Object unescapedValue = Rdn.unescapeValue( trimmedValue );

	if ( unescapedValue instanceof String )
	{
	ava = new Ava(
	type,
	type,
	new StringValue( trimmedValue, (String)unescapedValue ),
	upName
	);
	}
	else
	{
	ava = new Ava(
	type,
	type,
	new BinaryValue( (byte[])unescapedValue ),
	upName
	);
	}
	}
	else
	{
	ava = new Ava(
	type,
	type,
	new BinaryValue( (byte[])value.value ),
	upName
	);
	}

	rdn.addAVA( null, ava );
	}
	catch ( LdapInvalidDnException e )
	{
	throw new SemanticException( e.getMessage() );
	}
	}
	)
	;


	/**
	* RFC 4514 Section 3
	*
	* attributeType = descr / numericoid
	*
	*/
	attributeType returns [String attributeType]
	{
	matchedProduction( "attributeType()" );
	}
	:
	(
	attributeType = descr
	\|
	attributeType = numericoid
	)
	;


	/**
	* RFC 4512 Section 1.4
	*
	* descr = keystring
	* keystring = leadkeychar *keychar
	* leadkeychar = ALPHA
	* keychar = ALPHA / DIGIT / HYPHEN
	*
	* We additionally add UNDERSCORE because some servers allow them.
	*
	*/
	descr returns [String descr]
	{
	matchedProduction( "descr()" );
	}
	:
	leadkeychar:ALPHA { descr = leadkeychar.getText(); }
	(
	alpha:ALPHA { descr += alpha.getText(); }
	\|
	digit:DIGIT { descr += digit.getText(); }
	\|
	hyphen:HYPHEN { descr += hyphen.getText(); }
	\|
	underscore:UNDERSCORE { descr += underscore.getText(); }
	)*
	;


	/**
	* RFC 4512 Section 1.4
	*
	* numericoid = number 1*( DOT number )
	* number = DIGIT / ( LDIGIT 1*DIGIT )
	* DIGIT = %x30 / LDIGIT ; "0"-"9"
	* LDIGIT = %x31-39 ; "1"-"9"
	*
	*/
	numericoid returns [String numericoid = ""]
	{
	matchedProduction( "numericoid()" );
	}
	:
	noid:NUMERICOID { numericoid += noid.getText(); }
	;


	/**
	* RFC 4514, Section 3
	* attributeValue = string / hexstring
	*
	* RFC 2253, Section 3
	* attributeValue = string
	* string = *( stringchar / pair )
	* / "#" hexstring
	* / QUOTATION *( quotechar / pair ) QUOTATION ; only from v2
	*
	*/
	attributeValue [UpAndNormValue value]
	{
	matchedProduction( "attributeValue()" );
	}
	:
	(
	(
	quotestring [value]
	( SPACE { value.rawValue += " "; } )*
	)
	\|
	string [value]
	\|
	(
	hexstring [value]
	( SPACE { value.rawValue += " "; } )*
	)
	)?
	;


	/**
	* RFC 2253, Section 3
	* / QUOTATION *( quotechar / pair ) QUOTATION ; only from v2
	* quotechar = <any character except "\" or QUOTATION >
	*
	*/
	quotestring [UpAndNormValue value]
	{
	matchedProduction( "quotestring()" );
	org.apache.directory.api.util.ByteBuffer bb = new org.apache.directory.api.util.ByteBuffer();
	byte[] bytes;
	}
	:
	(
	dq1:DQUOTE { value.rawValue += dq1.getText(); }
	(
	(
	s:~(DQUOTE\|ESC\|ESCESC\|ESCSHARP\|HEXPAIR)
	{
	value.rawValue += s.getText();
	bb.append( Strings.getBytesUtf8( s.getText() ) );
	}
	)
	\|
	bytes = pair[value] { bb.append( bytes ); }
	)*
	dq2:DQUOTE { value.rawValue += dq2.getText(); }
	)
	{
	String string = Strings.utf8ToString( bb.copyOfUsedBytes() );
	value.value = string;
	}
	;


	/**
	* RFC 4514 Section 3
	*
	* hexstring = SHARP 1*hexpair
	*
	* If in <hexstring> form, a BER representation can be obtained from
	* converting each <hexpair> of the <hexstring> to the octet indicated
	* by the <hexpair>.
	*
	*/
	hexstring [UpAndNormValue value]
	{
	matchedProduction( "hexstring()" );
	}
	:
	hexValue:HEXVALUE
	{
	// convert to byte[]
	value.rawValue = "#" + hexValue.getText();
	value.value = Strings.toByteArray( hexValue.getText() );
	}
	;


	/**
	* RFC 4514 Section 3
	*
	* ; The following characters are to be escaped when they appear
	* ; in the value to be encoded: ESC, one of <escaped>, leading
	* ; SHARP or SPACE, trailing SPACE, and NULL.
	* string = [ ( leadchar / pair ) [ *( stringchar / pair )
	* ( trailchar / pair ) ] ]
	*
	*/
	string [UpAndNormValue value]
	{
	matchedProduction( "string()" );
	org.apache.directory.api.util.ByteBuffer bb = new org.apache.directory.api.util.ByteBuffer();
	String tmp;
	byte[] bytes;
	}
	:
	(
	(
	tmp = lutf1
	{
	value.rawValue += tmp;
	bb.append( Strings.getBytesUtf8( tmp ) );
	}
	\|
	tmp = utfmb
	{
	value.rawValue += tmp;
	bb.append( Strings.getBytesUtf8( tmp ) );
	}
	\|
	bytes = pair [value]
	{
	bb.append( bytes );
	}
	)
	(
	tmp = sutf1
	{
	value.rawValue += tmp;
	bb.append( Strings.getBytesUtf8( tmp ) );
	}
	\|
	tmp = utfmb
	{
	value.rawValue += tmp;
	bb.append( Strings.getBytesUtf8( tmp ) );
	}
	\|
	bytes = pair [value]
	{
	bb.append( bytes );
	}
	)*
	)
	{
	/*
	String string = Strings.utf8ToString( bb.copyOfUsedBytes() );

	// trim trailing space characters manually
	// don't know how to tell antlr that the last char mustn't be a space.
	int rawIndex = value.rawValue.length();
	while ( string.length() > 0 && rawIndex > 1
	&& value.rawValue.charAt( rawIndex - 1 ) == ' '
	&& value.rawValue.charAt( rawIndex - 2 ) != '\\' )
	{
	string = string.substring( 0, string.length() - 1 );
	rawIndex--;
	}

	value.value = string;
	*/
	}
	;


	/**
	* RFC 4514, Section 3:
	* LUTF1 = %x01-1F / %x21 / %x24-2A / %x2D-3A /
	* %x3D / %x3F-5B / %x5D-7F
	*
	* The rule LUTF1_REST doesn't contain the following charcters,
	* so we must check them additionally
	* EQUALS (0x3D)
	* HYPHEN (0x2D)
	* UNDERSCORE (0x5F)
	* DIGIT (0x30-0x39)
	* ALPHA (0x41-0x5A and 0x61-0x7A)
	*/
	lutf1 returns [String lutf1=""]
	{
	matchedProduction( "lutf1()" );
	}
	:
	rest:LUTF1_REST { lutf1 = rest.getText(); }
	\|
	equals:EQUALS { lutf1 = equals.getText(); }
	\|
	hyphen:HYPHEN { lutf1 = hyphen.getText(); }
	\|
	underscore:UNDERSCORE { lutf1 = underscore.getText(); }
	\|
	digit:DIGIT { lutf1 = digit.getText(); }
	\|
	alpha:ALPHA { lutf1 = alpha.getText(); }
	\|
	numericoid:NUMERICOID { lutf1 = numericoid.getText(); }
	;

	/**
	* RFC 4514, Section 3:
	* SUTF1 = %x01-21 / %x23-2A / %x2D-3A /
	* %x3D / %x3F-5B / %x5D-7F
	*
	* The rule LUTF1_REST doesn't contain the following charcters,
	* so we must check them additionally
	* EQUALS (0x3D)
	* HYPHEN (0x2D)
	* UNDERSCORE (0x5F)
	* DIGIT (0x30-0x39)
	* ALPHA (0x41-0x5A and 0x61-0x7A)
	* SHARP
	* SPACE
	*/
	sutf1 returns [String sutf1=""]
	{
	matchedProduction( "sutf1()" );
	}
	:
	rest:LUTF1_REST { sutf1 = rest.getText(); }
	\|
	equals:EQUALS { sutf1 = equals.getText(); }
	\|
	hyphen:HYPHEN { sutf1 = hyphen.getText(); }
	\|
	underscore:UNDERSCORE { sutf1 = underscore.getText(); }
	\|
	digit:DIGIT { sutf1 = digit.getText(); }
	\|
	alpha:ALPHA { sutf1 = alpha.getText(); }
	\|
	sharp:SHARP { sutf1 = sharp.getText(); }
	\|
	space:SPACE { sutf1 = space.getText(); }
	\|
	// This is a hack to deal with #NN included into the value, due to
	// some collision with the HEXVALUE token. In this case, we should
	// consider that a hex value is in fact a String
	hex:HEXVALUE { sutf1 = "#" + hex.getText(); }
	\|
	numericoid:NUMERICOID { sutf1 = numericoid.getText(); }
	;


	utfmb returns [String utfmb]
	{
	matchedProduction( "utfmb()" );
	}
	:
	s:UTFMB { utfmb = s.getText(); }
	;


	/**
	* RFC 4514, Section 3
	* pair = ESC ( ESC / special / hexpair )
	* special = escaped / SPACE / SHARP / EQUALS
	* escaped = DQUOTE / PLUS / COMMA / SEMI / LANGLE / RANGLE
	* hexpair = HEX HEX
	*
	* If in <string> form, a LDAP string representation asserted value can
	* be obtained by replacing (left to right, non-recursively) each <pair>
	* appearing in the <string> as follows:
	* replace <ESC><ESC> with <ESC>;
	* replace <ESC><special> with <special>;
	* replace <ESC><hexpair> with the octet indicated by the <hexpair>.
	*
	* RFC 2253, Section 3
	* pair = "\" ( special / "\" / QUOTATION / hexpair )
	* special = "," / "=" / "+" / "<" / ">" / "#" / ";"
	*
	* RFC 1779, Section 2.3
	* <pair> ::= "\" ( <special> \| "\" \| '"')
	* <special> ::= "," \| "=" \| <CR> \| "+" \| "<" \| ">"
	* \| "#" \| ";"
	*
	*/
	pair [UpAndNormValue value] returns [byte[] pair]
	{
	matchedProduction( "pair()" );
	String tmp;
	}
	:
	(
	ESCESC
	{
	value.rawValue += "\\\\";
	pair = Strings.getBytesUtf8( "\\" );
	}
	)
	\|
	(
	ESCSHARP
	{
	value.rawValue += "\\#";
	pair = Strings.getBytesUtf8( "#" );
	}
	)
	\|
	(
	ESC
	tmp = special
	{
	value.rawValue += "\\" + tmp;
	pair = Strings.getBytesUtf8( tmp );
	}
	)
	\|
	(
	hexpair:HEXPAIR
	{
	value.rawValue += "\\" + hexpair.getText();
	pair = Strings.toByteArray( hexpair.getText() );
	}
	)
	;


	/**
	* RFC 4514 Section 3
	*
	* special = escaped / SPACE / SHARP / EQUALS
	* escaped = DQUOTE / PLUS / COMMA / SEMI / LANGLE / RANGLE
	*
	*/
	special returns [String special]
	{
	matchedProduction( "special()" );
	}
	:
	(
	dquote:DQUOTE { special = dquote.getText(); }
	\|
	plus:PLUS { special = plus.getText(); }
	\|
	comma:COMMA { special = comma.getText(); }
	\|
	semi:SEMI { special = semi.getText(); }
	\|
	langle:LANGLE { special = langle.getText(); }
	\|
	rangle:RANGLE { special = rangle.getText(); }
	\|
	space:SPACE { special = space.getText(); }
	\|
	sharp:SHARP { special = sharp.getText(); }
	\|
	equals:EQUALS { special = equals.getText(); }
	)
	;