| 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.schema.syntaxes; |
| |
| 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.schema.parsers.LdapComparatorDescription; |
| 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.MutableMatchingRule; |
| import org.apache.directory.api.ldap.model.schema.MatchingRuleUse; |
| import org.apache.directory.api.ldap.model.schema.NameForm; |
| import org.apache.directory.api.ldap.model.schema.parsers.NormalizerDescription; |
| import org.apache.directory.api.ldap.model.schema.parsers.ParserMonitor; |
| import org.apache.directory.api.ldap.model.schema.AttributeType; |
| import org.apache.directory.api.ldap.model.schema.MutableAttributeType; |
| import org.apache.directory.api.ldap.model.schema.ObjectClass; |
| import org.apache.directory.api.ldap.model.schema.MutableObjectClass; |
| import org.apache.directory.api.ldap.model.schema.parsers.SyntaxCheckerDescription; |
| import org.apache.directory.api.ldap.model.schema.syntaxCheckers.OpenLdapObjectIdentifierMacro; |
| import org.apache.directory.api.ldap.model.schema.ObjectClassTypeEnum; |
| import org.apache.directory.api.ldap.model.schema.UsageEnum; |
| |
| } |
| |
| /** |
| * An antlr generated schema main lexer. |
| * |
| * @author <a href="mailto:dev@directory.apache.org">Apache Directory Project</a> |
| */ |
| class AntlrSchemaLexer extends Lexer; |
| |
| options { |
| k = 8 ; |
| exportVocab=AntlrSchema ; |
| charVocabulary = '\u0000'..'\uFFFE'; |
| caseSensitive = false ; |
| defaultErrorHandler = false ; |
| } |
| |
| WHSP |
| : |
| ( options {greedy=true;} : |
| ' ' |
| | |
| '\t' |
| | |
| '\r' (options {greedy=true;} : '\n')? { newline(); } |
| | |
| '\n' { newline(); } |
| | |
| '#' (~'\n')* '\n' { newline(); } |
| )+ |
| {$setType(Token.SKIP);} //ignore this token |
| ; |
| |
| LPAR : '(' ; |
| RPAR : ')' ; |
| QUOTE : '\'' ; |
| DOLLAR : '$' ; |
| LBRACKET : '{' ; |
| RBRACKET : '}' ; |
| |
| LEN : LBRACKET ('0'..'9')+ RBRACKET ; |
| |
| SINGLE_VALUE : ( "single-value" (WHSP)? ) ; |
| COLLECTIVE : ( "collective" (WHSP)? ) ; |
| NO_USER_MODIFICATION : ( "no-user-modification" (WHSP)? ) ; |
| |
| OBSOLETE : ( "obsolete" (WHSP)? ) ; |
| ABSTRACT : ( "abstract" (WHSP)? ) ; |
| STRUCTURAL : ( "structural" (WHSP)? ) ; |
| protected AUXILIARY : ( "auxiliary" (WHSP)? ) ; |
| |
| OBJECTIDENTIFIER : |
| ( "objectidentifier" |
| WHSP |
| ( oiName:UNQUOTED_STRING ) |
| WHSP |
| ( oiValue:UNQUOTED_STRING ) |
| ) |
| { setText( oiName.getText() + " " + oiValue.getText() ); } |
| ; |
| |
| OBJECTCLASS : ( "objectclass" (WHSP)? ) ; |
| ATTRIBUTETYPE : ( "attributetype" (WHSP)? ) ; |
| |
| STARTNUMERICOID : ( LPAR (options {greedy=true;} : WHSP)? ( numericoid:VALUES ) ) { setText(numericoid.getText()); } ; |
| NAME : ( "name" (options {greedy=true;} : WHSP)? qdstrings:VALUES ) { setText(qdstrings.getText().trim()); } ; |
| DESC : ( "desc" (options {greedy=true;} : WHSP)? qdstring:VALUES ) { setText(qdstring.getText().trim()); } ; |
| SUP : ( "sup" (options {greedy=true;} : WHSP)? sup:VALUES ) { setText(sup.getText().trim()); } ; |
| MUST : ( "must" (options {greedy=true;} : WHSP)? must:VALUES ) { setText(must.getText().trim()); } ; |
| MAY : ( "may" (options {greedy=true;} : WHSP)? may:VALUES ) { setText(may.getText()); } ; |
| protected AUX : ( "aux" (options {greedy=true;} : WHSP)? aux:VALUES ) { setText(aux.getText()); } ; |
| NOT : ( "not" (options {greedy=true;} : WHSP)? not:VALUES ) { setText(not.getText()); } ; |
| FORM : ( "form" (options {greedy=true;} : WHSP)? form:VALUES ) { setText(form.getText()); } ; |
| OC : ( "oc" (options {greedy=true;} : WHSP)? oc:VALUES ) { setText(oc.getText()); } ; |
| EQUALITY : ( "equality" (options {greedy=true;} : WHSP)? equality:VALUES ) { setText(equality.getText().trim()); } ; |
| ORDERING : ( "ordering" (options {greedy=true;} : WHSP)? ordering:VALUES ) { setText(ordering.getText().trim()); } ; |
| SUBSTR : ( "substr" (options {greedy=true;} : WHSP)? substring:VALUES ) { setText(substring.getText().trim()); } ; |
| SYNTAX : ( "syntax" (options {greedy=true;} : WHSP)? syntax:VALUES (len:LEN)? ) { setText(syntax.getText().trim() + (len!=null?len.getText().trim():"")); } ; |
| APPLIES : ( "applies" (options {greedy=true;} : WHSP)? applies:VALUES ) { setText(applies.getText().trim()); } ; |
| EXTENSION : x:( "x-" ( options {greedy=true;} : 'a'..'z' | '-' | '_' )+ (options {greedy=true;} : WHSP)? VALUES ) ; |
| FQCN : ( "fqcn" (options {greedy=true;} : WHSP)? fqcn:FQCN_VALUE ) { setText(fqcn.getText().trim()); } ; |
| BYTECODE : ( "bytecode" (options {greedy=true;} : WHSP)? bytecode:BYTECODE_VALUE ) { setText(bytecode.getText().trim()); } ; |
| |
| AUX_OR_AUXILIARY : |
| ( AUXILIARY ) => AUXILIARY { $setType( AUXILIARY ); } |
| | |
| ( AUX ) { $setType( AUX ); } |
| ; |
| |
| protected VALUES : ( VALUE | LPAR VALUE ( (DOLLAR)? VALUE )* RPAR ) ; |
| protected VALUE : (WHSP)? ( QUOTED_STRING | UNQUOTED_STRING ) (options {greedy=true;}: WHSP)? ; |
| protected UNQUOTED_STRING : (options{greedy=true;}: 'a'..'z' | '0'..'9' | '-' | '_' | ';' | '.' | ':' )+ ; |
| protected QUOTED_STRING : ( QUOTE (~'\'')* QUOTE ) ; |
| protected FQCN_VALUE : ( FQCN_IDENTIFIER ( '.' FQCN_IDENTIFIER )* ) ; |
| protected FQCN_IDENTIFIER : ( FQCN_LETTER ( FQCN_LETTERORDIGIT )* ) ; |
| protected FQCN_LETTER : |
| '\u0024' | |
| '\u005f' | |
| '\u0061'..'\u007a' | |
| '\u00c0'..'\u00d6' | |
| '\u00d8'..'\u00f6' | |
| '\u00f8'..'\u00ff' | |
| '\u0100'..'\u1fff' | |
| '\u3040'..'\u318f' | |
| '\u3300'..'\u337f' | |
| '\u3400'..'\u3d2d' | |
| '\u4e00'..'\u9fff' | |
| '\uf900'..'\ufaff' ; |
| protected FQCN_LETTERORDIGIT : |
| '\u0024' | |
| '\u005f' | |
| '\u0061'..'\u007a' | |
| '\u00c0'..'\u00d6' | |
| '\u00d8'..'\u00f6' | |
| '\u00f8'..'\u00ff' | |
| '\u0100'..'\u1fff' | |
| '\u3040'..'\u318f' | |
| '\u3300'..'\u337f' | |
| '\u3400'..'\u3d2d' | |
| '\u4e00'..'\u9fff' | |
| '\uf900'..'\ufaff' | |
| '\u0030'..'\u0039' ; |
| protected BYTECODE_VALUE : ( 'a'..'z' | '0'..'9' | '+' | '/' | '=' )+ ; |
| |
| |
| USAGE : ( "usage" (WHSP)? ) ; |
| USER_APPLICATIONS : ( "userapplications" (WHSP)? ) ; |
| DIRECTORY_OPERATION : ( "directoryoperation" (WHSP)? ) ; |
| DISTRIBUTED_OPERATION : ( "distributedoperation" (WHSP)? ) ; |
| DSA_OPERATION : ( "dsaoperation" (WHSP)? ) ; |
| |
| /** |
| * An antlr generated schema main parser. |
| * |
| * @author <a href="mailto:dev@directory.apache.org">Apache Directory Project</a> |
| */ |
| class AntlrSchemaParser extends Parser; |
| options { |
| k = 3 ; |
| defaultErrorHandler = false ; |
| //buildAST=true ; |
| } |
| |
| { |
| private ParserMonitor monitor = null; |
| private boolean isQuirksModeEnabled = false; |
| public void setParserMonitor( ParserMonitor monitor ) |
| { |
| this.monitor = monitor; |
| } |
| private void matchedProduction( String msg ) |
| { |
| if ( null != monitor ) |
| { |
| monitor.matchedProduction( msg ); |
| } |
| } |
| public void setQuirksMode( boolean enabled ) |
| { |
| this.isQuirksModeEnabled = enabled; |
| } |
| public boolean isQuirksMode() |
| { |
| return this.isQuirksModeEnabled; |
| } |
| static class Extension |
| { |
| String key = ""; |
| List<String> values = new ArrayList<String>(); |
| |
| public void addValue( String value ) |
| { |
| this.values.add( value ); |
| } |
| } |
| static class NoidLen |
| { |
| String noid = ""; |
| long len = 0L; |
| } |
| static class ElementTracker |
| { |
| Map<String, Integer> elementMap = new HashMap<String, Integer>(); |
| void track(String element, Token token) throws SemanticException |
| { |
| if(elementMap.containsKey(element)) |
| { |
| throw new SemanticException( element + " appears twice.", token.getFilename(), token.getLine() , token.getColumn() ); |
| } |
| elementMap.put(element, Integer.valueOf(1)); |
| } |
| boolean contains(String element) |
| { |
| return elementMap.containsKey(element); |
| } |
| } |
| |
| } |
| |
| openLdapSchema returns [List<Object> list = new ArrayList<Object>()] |
| { |
| AttributeType attributeType = null; |
| ObjectClass objectClass = null; |
| OpenLdapObjectIdentifierMacro oloid = null; |
| } |
| : |
| ( |
| oloid = openLdapObjectIdentifier { list.add( oloid ); } |
| | |
| attributeType = openLdapAttributeType { list.add( attributeType ); } |
| | |
| objectClass = openLdapObjectClass { list.add( objectClass ); } |
| )* |
| ; |
| |
| openLdapObjectIdentifier returns [OpenLdapObjectIdentifierMacro oloid] |
| { |
| matchedProduction( "openLdapObjectIdentifier()" ); |
| } |
| : |
| ( |
| oi:OBJECTIDENTIFIER |
| { |
| String[] nameAndValue = oi.getText().split( " " ); |
| oloid = new OpenLdapObjectIdentifierMacro(); |
| oloid.setName( nameAndValue[0] ); |
| oloid.setRawOidOrNameSuffix( nameAndValue[1] ); |
| } |
| ) |
| ; |
| |
| |
| openLdapObjectClass returns [ObjectClass objectClass] |
| { |
| matchedProduction( "openLdapObjectClass()" ); |
| } |
| : |
| ( |
| OBJECTCLASS |
| ( objectClass=objectClassDescription ) |
| ) |
| ; |
| |
| |
| openLdapAttributeType returns [AttributeType attributeType] |
| { |
| matchedProduction( "openLdapAttributeType()" ); |
| } |
| : |
| ( |
| ATTRIBUTETYPE |
| ( attributeType=attributeTypeDescription ) |
| ) |
| ; |
| |
| |
| /** |
| * Production for matching object class 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" |
| * |
| * extensions = *( SP xstring SP qdstrings ) |
| * xstring = "X" HYPHEN 1*( ALPHA / HYPHEN / USCORE ) |
| * </pre> |
| */ |
| objectClassDescription returns [MutableObjectClass objectClass] |
| { |
| matchedProduction( "objectClassDescription()" ); |
| ElementTracker et = new ElementTracker(); |
| } |
| : |
| ( oid:STARTNUMERICOID { objectClass = new MutableObjectClass(numericoid(oid.getText())); } ) |
| ( |
| ( name:NAME { et.track("NAME", name); objectClass.setNames(qdescrs(name.getText())); } ) |
| | |
| ( desc:DESC { et.track("DESC", desc); objectClass.setDescription(qdstring(desc.getText())); } ) |
| | |
| ( obsolete:OBSOLETE { et.track("OBSOLETE", obsolete); objectClass.setObsolete( true ); } ) |
| | |
| ( sup:SUP { et.track("SUP", sup); objectClass.setSuperiorOids(oids(sup.getText())); } ) |
| | |
| ( kind1:ABSTRACT { et.track("KIND", kind1); objectClass.setType( ObjectClassTypeEnum.ABSTRACT ); } |
| | |
| kind2:STRUCTURAL { et.track("KIND", kind2); objectClass.setType( ObjectClassTypeEnum.STRUCTURAL ); } |
| | |
| kind3:AUXILIARY { et.track("KIND", kind3); objectClass.setType( ObjectClassTypeEnum.AUXILIARY ); } |
| ) |
| | |
| ( must:MUST { et.track("MUST", must); objectClass.setMustAttributeTypeOids(oids(must.getText())); } ) |
| | |
| ( may:MAY { et.track("MAY", may); objectClass.setMayAttributeTypeOids(oids(may.getText())); } ) |
| | |
| ( extension:EXTENSION { |
| Extension ex = extension(extension.getText()); |
| et.track(ex.key, extension); |
| objectClass.addExtension(ex.key, ex.values); |
| } ) |
| )* |
| RPAR |
| ; |
| |
| |
| /** |
| * 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> |
| */ |
| attributeTypeDescription returns [MutableAttributeType attributeType] |
| { |
| matchedProduction( "attributeTypeDescription()" ); |
| ElementTracker et = new ElementTracker(); |
| } |
| : |
| ( oid:STARTNUMERICOID { attributeType = new MutableAttributeType(numericoid(oid.getText())); } ) |
| ( |
| ( name:NAME { et.track("NAME", name); attributeType.setNames(qdescrs(name.getText())); } ) |
| | |
| ( desc:DESC { et.track("DESC", desc); attributeType.setDescription(qdstring(desc.getText())); } ) |
| | |
| ( obsolete:OBSOLETE { et.track("OBSOLETE", obsolete); attributeType.setObsolete( true ); } ) |
| | |
| ( superior:SUP { et.track("SUP", superior); attributeType.setSuperiorOid(oid(superior.getText())); } ) |
| | |
| ( equality:EQUALITY { et.track("EQUALITY", equality); attributeType.setEqualityOid(oid(equality.getText())); } ) |
| | |
| ( ordering:ORDERING { et.track("ORDERING", ordering); attributeType.setOrderingOid(oid(ordering.getText())); } ) |
| | |
| ( substring:SUBSTR { et.track("SUBSTR", substring); attributeType.setSubstringOid(oid(substring.getText())); } ) |
| | |
| ( syntax:SYNTAX { |
| et.track("SYNTAX", syntax); |
| NoidLen noidlen = noidlen(syntax.getText()); |
| attributeType.setSyntaxOid(noidlen.noid); |
| attributeType.setSyntaxLength(noidlen.len); |
| } ) |
| | |
| ( singleValued:SINGLE_VALUE { et.track("SINGLE_VALUE", singleValued); attributeType.setSingleValued( true ); } ) |
| | |
| ( collective:COLLECTIVE { et.track("COLLECTIVE", collective); attributeType.setCollective( true ); } ) |
| | |
| ( noUserModification:NO_USER_MODIFICATION { et.track("NO_USER_MODIFICATION", noUserModification); attributeType.setUserModifiable( false ); } ) |
| | |
| ( usage1:USAGE (WHSP)* USER_APPLICATIONS { et.track("USAGE", usage1); attributeType.setUsage( UsageEnum.USER_APPLICATIONS ); } |
| | |
| usage2:USAGE DIRECTORY_OPERATION { et.track("USAGE", usage2); attributeType.setUsage( UsageEnum.DIRECTORY_OPERATION ); } |
| | |
| usage3:USAGE DISTRIBUTED_OPERATION { et.track("USAGE", usage3); attributeType.setUsage( UsageEnum.DISTRIBUTED_OPERATION ); } |
| | |
| usage4:USAGE DSA_OPERATION { et.track("USAGE", usage4); attributeType.setUsage( UsageEnum.DSA_OPERATION ); } |
| ) |
| | |
| ( extension:EXTENSION { |
| Extension ex = extension(extension.getText()); |
| et.track(ex.key, extension); |
| attributeType.addExtension(ex.key, ex.values); |
| } ) |
| )* |
| RPAR |
| { |
| if( !isQuirksModeEnabled ) |
| { |
| // semantic check: required elements |
| if( !et.contains("SYNTAX") && !et.contains("SUP") ) |
| { |
| throw new SemanticException( "One of SYNTAX or SUP is required", null, 0, 0 ); |
| } |
| |
| // COLLECTIVE requires USAGE userApplications |
| if ( attributeType.isCollective() && ( attributeType.getUsage() != UsageEnum.USER_APPLICATIONS ) ) |
| { |
| throw new SemanticException( "COLLECTIVE requires USAGE userApplications", null, 0, 0 ); |
| } |
| |
| // NO-USER-MODIFICATION requires an operational USAGE. |
| if ( !attributeType.isUserModifiable() && ( attributeType.getUsage() == UsageEnum.USER_APPLICATIONS ) ) |
| { |
| throw new SemanticException( "NO-USER-MODIFICATION requires an operational USAGE", null, 0, 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> |
| */ |
| ldapSyntaxDescription returns [LdapSyntax ldapSyntax] |
| { |
| matchedProduction( "ldapSyntaxDescription()" ); |
| ElementTracker et = new ElementTracker(); |
| } |
| : |
| ( oid:STARTNUMERICOID { ldapSyntax = new LdapSyntax(numericoid(oid.getText())); } ) |
| ( |
| ( name:NAME { et.track("NAME", name); ldapSyntax.setNames(qdescrs(name.getText())); } ) |
| | |
| ( desc:DESC { et.track("DESC", desc); ldapSyntax.setDescription(qdstring(desc.getText())); } ) |
| | |
| ( extension:EXTENSION { |
| Extension ex = extension(extension.getText()); |
| et.track(ex.key, extension); |
| ldapSyntax.addExtension(ex.key, ex.values); |
| } ) |
| )* |
| RPAR |
| ; |
| |
| |
| |
| /** |
| * 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> |
| */ |
| matchingRuleDescription returns [MutableMatchingRule matchingRule] |
| { |
| matchedProduction( "matchingRuleDescription()" ); |
| ElementTracker et = new ElementTracker(); |
| } |
| : |
| ( oid:STARTNUMERICOID { matchingRule = new MutableMatchingRule(numericoid(oid.getText())); } ) |
| ( |
| ( name:NAME { et.track("NAME", name); matchingRule.setNames(qdescrs(name.getText())); } ) |
| | |
| ( desc:DESC { et.track("DESC", desc); matchingRule.setDescription(qdstring(desc.getText())); } ) |
| | |
| ( obsolete:OBSOLETE { et.track("OBSOLETE", obsolete); matchingRule.setObsolete( true ); } ) |
| | |
| ( syntax:SYNTAX { et.track("SYNTAX", syntax); matchingRule.setSyntaxOid(numericoid(syntax.getText())); } ) |
| | |
| ( extension:EXTENSION { |
| Extension ex = extension(extension.getText()); |
| et.track(ex.key, extension); |
| matchingRule.addExtension(ex.key, ex.values); |
| } ) |
| )* |
| RPAR |
| { |
| if( !isQuirksModeEnabled ) |
| { |
| // semantic check: required elements |
| if( !et.contains("SYNTAX") ) { |
| throw new SemanticException( "SYNTAX is required", null, 0, 0 ); |
| } |
| } |
| } |
| ; |
| |
| |
| /** |
| * Production for matching rule use 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> |
| */ |
| matchingRuleUseDescription returns [MatchingRuleUse matchingRuleUse] |
| { |
| matchedProduction( "matchingRuleUseDescription()" ); |
| ElementTracker et = new ElementTracker(); |
| } |
| : |
| ( oid:STARTNUMERICOID { matchingRuleUse = new MatchingRuleUse(numericoid(oid.getText())); } ) |
| ( |
| ( name:NAME { et.track("NAME", name); matchingRuleUse.setNames(qdescrs(name.getText())); } ) |
| | |
| ( desc:DESC { et.track("DESC", desc); matchingRuleUse.setDescription(qdstring(desc.getText())); } ) |
| | |
| ( obsolete:OBSOLETE { et.track("OBSOLETE", obsolete); matchingRuleUse.setObsolete( true ); } ) |
| | |
| ( applies:APPLIES { et.track("APPLIES", applies); matchingRuleUse.setApplicableAttributeOids(oids(applies.getText())); } ) |
| | |
| ( extension:EXTENSION { |
| Extension ex = extension(extension.getText()); |
| et.track(ex.key, extension); |
| matchingRuleUse.addExtension(ex.key, ex.values); |
| } ) |
| )* |
| RPAR |
| { |
| if( !isQuirksModeEnabled ) |
| { |
| // semantic check: required elements |
| if( !et.contains("APPLIES") ) { |
| throw new SemanticException( "APPLIES is required", null, 0, 0 ); |
| } |
| } |
| } |
| ; |
| |
| |
| /** |
| * Production for DIT content rule 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> |
| */ |
| ditContentRuleDescription returns [DitContentRule ditContentRule] |
| { |
| matchedProduction( "ditContentRuleDescription()" ); |
| ElementTracker et = new ElementTracker(); |
| } |
| : |
| ( oid:STARTNUMERICOID { ditContentRule = new DitContentRule(numericoid(oid.getText())); } ) |
| ( |
| ( name:NAME { et.track("NAME", name); ditContentRule.setNames(qdescrs(name.getText())); } ) |
| | |
| ( desc:DESC { et.track("DESC", desc); ditContentRule.setDescription(qdstring(desc.getText())); } ) |
| | |
| ( obsolete:OBSOLETE { et.track("OBSOLETE", obsolete); ditContentRule.setObsolete( true ); } ) |
| | |
| ( aux:AUX { et.track("AUX", aux); ditContentRule.setAuxObjectClassOids(oids(aux.getText())); } ) |
| | |
| ( must:MUST { et.track("MUST", must); ditContentRule.setMustAttributeTypeOids(oids(must.getText())); } ) |
| | |
| ( may:MAY { et.track("MAY", may); ditContentRule.setMayAttributeTypeOids(oids(may.getText())); } ) |
| | |
| ( not:NOT { et.track("NOT", not); ditContentRule.setNotAttributeTypeOids(oids(not.getText())); } ) |
| | |
| ( extension:EXTENSION { |
| Extension ex = extension(extension.getText()); |
| et.track(ex.key, extension); |
| ditContentRule.addExtension(ex.key, ex.values); |
| } ) |
| )* |
| RPAR |
| ; |
| |
| |
| /** |
| * Production for DIT structure rules 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> |
| */ |
| ditStructureRuleDescription returns [DitStructureRule ditStructureRule] |
| { |
| matchedProduction( "ditStructureRuleDescription()" ); |
| ElementTracker et = new ElementTracker(); |
| } |
| : |
| ( ruleid:STARTNUMERICOID { ditStructureRule = new DitStructureRule(ruleid(ruleid.getText())); } ) |
| ( |
| ( name:NAME { et.track("NAME", name); ditStructureRule.setNames(qdescrs(name.getText())); } ) |
| | |
| ( desc:DESC { et.track("DESC", desc); ditStructureRule.setDescription(qdstring(desc.getText())); } ) |
| | |
| ( obsolete:OBSOLETE { et.track("OBSOLETE", obsolete); ditStructureRule.setObsolete( true ); } ) |
| | |
| ( form:FORM { et.track("FORM", form); ditStructureRule.setForm(oid(form.getText())); } ) |
| | |
| ( sup:SUP { et.track("SUP", sup); ditStructureRule.setSuperRules(ruleids(sup.getText())); } ) |
| | |
| ( extension:EXTENSION { |
| Extension ex = extension(extension.getText()); |
| et.track(ex.key, extension); |
| ditStructureRule.addExtension(ex.key, ex.values); |
| } ) |
| )* |
| RPAR |
| { |
| if( !isQuirksModeEnabled ) |
| { |
| // semantic check: required elements |
| if( !et.contains("FORM") ) { |
| throw new SemanticException( "FORM is required", null, 0, 0 ); |
| } |
| } |
| } |
| ; |
| |
| |
| /** |
| * Production for name form 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> |
| */ |
| nameFormDescription returns [NameForm nameForm] |
| { |
| matchedProduction( "nameFormDescription()" ); |
| ElementTracker et = new ElementTracker(); |
| } |
| : |
| ( oid:STARTNUMERICOID { nameForm = new NameForm(numericoid(oid.getText())); } ) |
| ( |
| ( name:NAME { et.track("NAME", name); nameForm.setNames(qdescrs(name.getText())); } ) |
| | |
| ( desc:DESC { et.track("DESC", desc); nameForm.setDescription(qdstring(desc.getText())); } ) |
| | |
| ( obsolete:OBSOLETE { et.track("OBSOLETE", obsolete); nameForm.setObsolete( true ); } ) |
| | |
| ( oc:OC { et.track("OC", oc); nameForm.setStructuralObjectClassOid(oid(oc.getText())); } ) |
| | |
| ( must:MUST { et.track("MUST", must); nameForm.setMustAttributeTypeOids(oids(must.getText())); } ) |
| | |
| ( may:MAY { et.track("MAY", may); nameForm.setMayAttributeTypeOids(oids(may.getText())); } ) |
| | |
| ( extension:EXTENSION { |
| Extension ex = extension(extension.getText()); |
| et.track(ex.key, extension); |
| nameForm.addExtension(ex.key, ex.values); |
| } ) |
| )* |
| RPAR |
| { |
| if( !isQuirksModeEnabled ) |
| { |
| // semantic check: required elements |
| if( !et.contains("MUST") ) { |
| throw new SemanticException( "MUST is required", null, 0, 0 ); |
| } |
| if( !et.contains("OC") ) { |
| throw new SemanticException( "OC is required", null, 0, 0 ); |
| } |
| |
| // semantic check: MUST and MAY must be disjoint |
| //List<String> aList = new ArrayList<String>( nfd.getMustAttributeTypes() ); |
| //aList.retainAll( nfd.getMayAttributeTypes() ); |
| //if( !aList.isEmpty() ) |
| //{ |
| // throw new SemanticException( "MUST and MAY must be disjoint, "+aList.get( 0 )+" appears in both", null, 0, 0 ); |
| //} |
| } |
| } |
| ; |
| |
| |
| /** |
| * Production for comparator descriptions. It is fault-tolerant |
| * against element ordering. |
| * |
| * <pre> |
| * LdapComparator = 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> |
| */ |
| ldapComparator returns [LdapComparatorDescription lcd] |
| { |
| matchedProduction( "ldapComparator()" ); |
| ElementTracker et = new ElementTracker(); |
| } |
| : |
| ( oid:STARTNUMERICOID { lcd = new LdapComparatorDescription(numericoid(oid.getText())); } ) |
| ( |
| ( desc:DESC { et.track("DESC", desc); lcd.setDescription(qdstring(desc.getText())); } ) |
| | |
| ( fqcn:FQCN { et.track("FQCN", fqcn); lcd.setFqcn(fqcn.getText()); } ) |
| | |
| ( bytecode:BYTECODE { et.track("BYTECODE", bytecode); lcd.setBytecode(bytecode.getText()); } ) |
| | |
| ( extension:EXTENSION { |
| Extension ex = extension(extension.getText()); |
| et.track(ex.key, extension); |
| lcd.addExtension(ex.key, ex.values); |
| } ) |
| )* |
| RPAR |
| { |
| if( !isQuirksModeEnabled ) |
| { |
| // semantic check: required elements |
| if( !et.contains("FQCN") ) { |
| throw new SemanticException( "FQCN is required", null, 0, 0 ); |
| } |
| |
| // semantic check: length should be divisible by 4 |
| if( ( lcd.getBytecode() != null ) && ( lcd.getBytecode().length() % 4 != 0 ) ) { |
| throw new SemanticException( "BYTECODE must be divisible by 4", null, 0, 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> |
| */ |
| normalizerDescription returns [NormalizerDescription nd] |
| { |
| matchedProduction( "normalizerDescription()" ); |
| ElementTracker et = new ElementTracker(); |
| } |
| : |
| ( oid:STARTNUMERICOID { nd = new NormalizerDescription(numericoid(oid.getText())); } ) |
| ( |
| ( desc:DESC { et.track("DESC", desc); nd.setDescription(qdstring(desc.getText())); } ) |
| | |
| ( fqcn:FQCN { et.track("FQCN", fqcn); nd.setFqcn(fqcn.getText()); } ) |
| | |
| ( bytecode:BYTECODE { et.track("BYTECODE", bytecode); nd.setBytecode(bytecode.getText()); } ) |
| | |
| ( extension:EXTENSION { |
| Extension ex = extension(extension.getText()); |
| et.track(ex.key, extension); |
| nd.addExtension(ex.key, ex.values); |
| } ) |
| )* |
| RPAR |
| { |
| if( !isQuirksModeEnabled ) |
| { |
| // semantic check: required elements |
| if( !et.contains("FQCN") ) { |
| throw new SemanticException( "FQCN is required", null, 0, 0 ); |
| } |
| |
| // semantic check: length should be divisible by 4 |
| if( nd.getBytecode() != null && ( nd.getBytecode().length() % 4 != 0 ) ) { |
| throw new SemanticException( "BYTECODE must be divisible by 4", null, 0, 0 ); |
| } |
| } |
| } |
| ; |
| |
| |
| /** |
| * Production for syntax checker 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> |
| */ |
| syntaxCheckerDescription returns [SyntaxCheckerDescription scd] |
| { |
| matchedProduction( "syntaxCheckerDescription()" ); |
| ElementTracker et = new ElementTracker(); |
| } |
| : |
| ( oid:STARTNUMERICOID { scd = new SyntaxCheckerDescription(numericoid(oid.getText())); } ) |
| ( |
| ( desc:DESC { et.track("DESC", desc); scd.setDescription(qdstring(desc.getText())); } ) |
| | |
| ( fqcn:FQCN { et.track("FQCN", fqcn); scd.setFqcn(fqcn.getText()); } ) |
| | |
| ( bytecode:BYTECODE { et.track("BYTECODE", bytecode); scd.setBytecode(bytecode.getText()); } ) |
| | |
| ( extension:EXTENSION { |
| Extension ex = extension(extension.getText()); |
| et.track(ex.key, extension); |
| scd.addExtension(ex.key, ex.values); |
| } ) |
| )* |
| RPAR |
| { |
| if( !isQuirksModeEnabled ) |
| { |
| // semantic check: required elements |
| if( !et.contains("FQCN") ) { |
| throw new SemanticException( "FQCN is required", null, 0, 0 ); |
| } |
| |
| // semantic check: length should be divisible by 4 |
| if( scd.getBytecode() != null && ( scd.getBytecode().length() % 4 != 0 ) ) { |
| throw new SemanticException( "BYTECODE must be divisible by 4", null, 0, 0 ); |
| } |
| } |
| } |
| ; |
| |
| |
| |
| |
| noidlen [String s] returns [NoidLen noidlen] |
| { |
| matchedProduction( "noidlen()" ); |
| AntlrSchemaValueLexer lexer = new AntlrSchemaValueLexer(new StringReader(s)); |
| AntlrSchemaValueParser parser = new AntlrSchemaValueParser(lexer); |
| parser.setParserMonitor(monitor); |
| noidlen = isQuirksModeEnabled ? parser.quirksNoidlen() : parser.noidlen(); |
| } |
| : |
| ; |
| |
| |
| extension [String s] returns [Extension extension] |
| { |
| matchedProduction( "extension()" ); |
| AntlrSchemaExtensionLexer lexer = new AntlrSchemaExtensionLexer(new StringReader(s)); |
| AntlrSchemaExtensionParser parser = new AntlrSchemaExtensionParser(lexer); |
| extension = parser.extension(); |
| } |
| : |
| ; |
| |
| |
| numericoid [String s] returns [String numericoid] |
| { |
| matchedProduction( "numericoid()"); |
| if(isQuirksModeEnabled) |
| { |
| numericoid = oid(s); |
| } |
| else |
| { |
| AntlrSchemaValueLexer lexer = new AntlrSchemaValueLexer(new StringReader(s)); |
| AntlrSchemaValueParser parser = new AntlrSchemaValueParser(lexer); |
| parser.setParserMonitor(monitor); |
| numericoid = parser.numericoid(); |
| } |
| } |
| : |
| ; |
| |
| oid [String s] returns [String oid] |
| { |
| matchedProduction( "oid()" ); |
| List<String> oids = oids(s); |
| if( oids.size() != 1 ) |
| { |
| throw new SemanticException( "Exactly one OID expected", null, 0, 0 ); |
| } |
| oid = oids.get(0); |
| } |
| : |
| ; |
| |
| oids [String s] returns [List<String> oids] |
| { |
| matchedProduction( "oids()" ); |
| if(isQuirksModeEnabled) |
| { |
| oids = qdescrs(s); |
| } |
| else |
| { |
| AntlrSchemaValueLexer lexer = new AntlrSchemaValueLexer(new StringReader(s)); |
| AntlrSchemaValueParser parser = new AntlrSchemaValueParser(lexer); |
| parser.setParserMonitor(monitor); |
| oids = parser.oids(); |
| } |
| } |
| : |
| ; |
| |
| qdescr [String s] returns [String qdescr] |
| { |
| matchedProduction( "qdescr()" ); |
| List<String> qdescrs = qdescrs(s); |
| if( qdescrs.size() != 1 ) |
| { |
| throw new SemanticException( "Exactly one qdescrs expected", null, 0, 0 ); |
| } |
| qdescr = qdescrs.get(0); |
| } |
| : |
| ; |
| |
| qdescrs [String s] returns [List<String> qdescrs] |
| { |
| matchedProduction( "qdescrs()" ); |
| AntlrSchemaValueLexer lexer = new AntlrSchemaValueLexer(new StringReader(s)); |
| AntlrSchemaValueParser parser = new AntlrSchemaValueParser(lexer); |
| parser.setParserMonitor(monitor); |
| qdescrs = isQuirksModeEnabled ? parser.quirksQdescrs() : parser.qdescrs(); |
| } |
| : |
| ; |
| |
| qdstring [String s] returns [String qdstring] |
| { |
| matchedProduction( "qdstring()" ); |
| List<String> qdstrings = qdstrings(s); |
| if( qdstrings.size() != 1 ) |
| { |
| throw new SemanticException( "Exactly one qdstrings expected", null, 0, 0 ); |
| } |
| qdstring = qdstrings.get(0); |
| } |
| : |
| ; |
| |
| qdstrings [String s] returns [List<String> qdstrings] |
| { |
| matchedProduction( "qdstrings()" ); |
| AntlrSchemaQdstringLexer lexer = new AntlrSchemaQdstringLexer(new StringReader(s)); |
| AntlrSchemaQdstringParser parser = new AntlrSchemaQdstringParser(lexer); |
| parser.setParserMonitor(monitor); |
| qdstrings = parser.qdstrings(); |
| } |
| : |
| ; |
| |
| ruleid [String s] returns [Integer ruleid] |
| { |
| matchedProduction( "ruleid()" ); |
| AntlrSchemaValueLexer lexer = new AntlrSchemaValueLexer(new StringReader(s)); |
| AntlrSchemaValueParser parser = new AntlrSchemaValueParser(lexer); |
| parser.setParserMonitor(monitor); |
| ruleid = parser.ruleid(); |
| } |
| : |
| ; |
| |
| ruleids [String s] returns [List<Integer> ruleids] |
| { |
| matchedProduction( "ruleids()" ); |
| AntlrSchemaValueLexer lexer = new AntlrSchemaValueLexer(new StringReader(s)); |
| AntlrSchemaValueParser parser = new AntlrSchemaValueParser(lexer); |
| parser.setParserMonitor(monitor); |
| ruleids = parser.ruleids(); |
| } |
| : |
| ; |
| |
| |
| |
