From 3a9a1b3a4f29fec7b48f074aa0292a2bda71c71d Mon Sep 17 00:00:00 2001 From: tokos Date: Fri, 7 Aug 2026 14:56:30 +0200 Subject: [PATCH] Fix Java 25 build compatibility: replace antlr-maven-plugin with exec-maven-plugin --- README.md | 11 + plugins/openldap.acl.editor/pom-first.xml | 4 +- plugins/openldap.acl.editor/pom.xml | 22 +- .../config/acl/model/AntlrAclLexer.java | 845 +++++++ .../config/acl/model/AntlrAclLexer.smap | 480 ++++ .../acl/model/AntlrAclLexerTokenTypes.java | 83 + .../acl/model/AntlrAclLexerTokenTypes.txt | 68 + .../config/acl/model/AntlrAclParser.java | 2225 +++++++++++++++++ .../config/acl/model/AntlrAclParser.smap | 1231 +++++++++ 9 files changed, 4946 insertions(+), 23 deletions(-) create mode 100644 plugins/openldap.acl.editor/src/main/java/org/apache/directory/studio/openldap/config/acl/model/AntlrAclLexer.java create mode 100644 plugins/openldap.acl.editor/src/main/java/org/apache/directory/studio/openldap/config/acl/model/AntlrAclLexer.smap create mode 100644 plugins/openldap.acl.editor/src/main/java/org/apache/directory/studio/openldap/config/acl/model/AntlrAclLexerTokenTypes.java create mode 100644 plugins/openldap.acl.editor/src/main/java/org/apache/directory/studio/openldap/config/acl/model/AntlrAclLexerTokenTypes.txt create mode 100644 plugins/openldap.acl.editor/src/main/java/org/apache/directory/studio/openldap/config/acl/model/AntlrAclParser.java create mode 100644 plugins/openldap.acl.editor/src/main/java/org/apache/directory/studio/openldap/config/acl/model/AntlrAclParser.smap diff --git a/README.md b/README.md index fcbc8c8237..04a1c895b6 100644 --- a/README.md +++ b/README.md @@ -47,6 +47,17 @@ Build the main eclipse artifacts using Tycho mvn clean install + +Special workaround for building with openjdk 25.0.4 2026-07-21 on Linux + +export MAVEN_OPTS="-Djdk.xml.maxGeneralEntitySizeLimit=0 -Djdk.xml.totalEntitySizeLimit=0 -Djdk.xml.entityExpansionLimit=0 + +# Step 1: Generate OSGi Manifests and ANTLR Java sources +mvn -f pom-first.xml clean install -DskipTests + +# Step 2: Build Tycho plugins and final application distributions +mvn clean install -DskipTests + #### Use the script (which runs the two previous commands) On Linux / macOS : diff --git a/plugins/openldap.acl.editor/pom-first.xml b/plugins/openldap.acl.editor/pom-first.xml index 31a6d0d6f0..42fe7634c4 100644 --- a/plugins/openldap.acl.editor/pom-first.xml +++ b/plugins/openldap.acl.editor/pom-first.xml @@ -44,7 +44,7 @@ org.codehaus.mojo - antlr-maven-plugin + exec-maven-plugin *.g @@ -52,7 +52,7 @@ - generate + java diff --git a/plugins/openldap.acl.editor/pom.xml b/plugins/openldap.acl.editor/pom.xml index a6ead75269..880f5476a3 100644 --- a/plugins/openldap.acl.editor/pom.xml +++ b/plugins/openldap.acl.editor/pom.xml @@ -37,24 +37,4 @@ provided - - - - - org.codehaus.mojo - antlr-maven-plugin - - *.g - - - - - generate - - - - - - - - + \ No newline at end of file diff --git a/plugins/openldap.acl.editor/src/main/java/org/apache/directory/studio/openldap/config/acl/model/AntlrAclLexer.java b/plugins/openldap.acl.editor/src/main/java/org/apache/directory/studio/openldap/config/acl/model/AntlrAclLexer.java new file mode 100644 index 0000000000..043e37b5c0 --- /dev/null +++ b/plugins/openldap.acl.editor/src/main/java/org/apache/directory/studio/openldap/config/acl/model/AntlrAclLexer.java @@ -0,0 +1,845 @@ +// $ANTLR 2.7.7 (20060906): "Acl.g" -> "AntlrAclLexer.java"$ + + +package org.apache.directory.studio.openldap.config.acl.model; + +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import org.apache.directory.api.ldap.model.name.Dn; +import org.apache.directory.api.ldap.model.exception.LdapInvalidDnException; + +import java.util.List; + +import java.io.InputStream; +import antlr.TokenStreamException; +import antlr.TokenStreamIOException; +import antlr.TokenStreamRecognitionException; +import antlr.CharStreamException; +import antlr.CharStreamIOException; +import antlr.ANTLRException; +import java.io.Reader; +import java.util.Hashtable; +import antlr.CharScanner; +import antlr.InputBuffer; +import antlr.ByteBuffer; +import antlr.CharBuffer; +import antlr.Token; +import antlr.CommonToken; +import antlr.RecognitionException; +import antlr.NoViableAltForCharException; +import antlr.MismatchedCharException; +import antlr.TokenStream; +import antlr.ANTLRHashString; +import antlr.LexerSharedInputState; +import antlr.collections.impl.BitSet; +import antlr.SemanticException; + +/** + * The ANTLR generated OpenLDAP ACL parser. + */ +public class AntlrAclLexer extends antlr.CharScanner implements AntlrAclLexerTokenTypes, TokenStream + { +public AntlrAclLexer(InputStream in) { + this(new ByteBuffer(in)); +} +public AntlrAclLexer(Reader in) { + this(new CharBuffer(in)); +} +public AntlrAclLexer(InputBuffer ib) { + this(new LexerSharedInputState(ib)); +} +public AntlrAclLexer(LexerSharedInputState state) { + super(state); + caseSensitiveLiterals = true; + setCaseSensitive(false); + literals = new Hashtable(); + literals.put(new ANTLRHashString("read", this), new Integer(33)); + literals.put(new ANTLRHashString("to", this), new Integer(41)); + literals.put(new ANTLRHashString("m", this), new Integer(26)); + literals.put(new ANTLRHashString("s", this), new Integer(35)); + literals.put(new ANTLRHashString("anonymous", this), new Integer(5)); + literals.put(new ANTLRHashString("expand", this), new Integer(22)); + literals.put(new ANTLRHashString("disclose", this), new Integer(17)); + literals.put(new ANTLRHashString("self", this), new Integer(37)); + literals.put(new ANTLRHashString("baseobject", this), new Integer(10)); + literals.put(new ANTLRHashString("base", this), new Integer(9)); + literals.put(new ANTLRHashString("matchingRule", this), new Integer(28)); + literals.put(new ANTLRHashString("r", this), new Integer(32)); + literals.put(new ANTLRHashString("x", this), new Integer(45)); + literals.put(new ANTLRHashString("subtree", this), new Integer(40)); + literals.put(new ANTLRHashString("group", this), new Integer(24)); + literals.put(new ANTLRHashString("onelevel", this), new Integer(31)); + literals.put(new ANTLRHashString("auth", this), new Integer(8)); + literals.put(new ANTLRHashString("w", this), new Integer(44)); + literals.put(new ANTLRHashString("one", this), new Integer(30)); + literals.put(new ANTLRHashString("access", this), new Integer(4)); + literals.put(new ANTLRHashString("none", this), new Integer(29)); + literals.put(new ANTLRHashString("exact", this), new Integer(21)); + literals.put(new ANTLRHashString("continue", this), new Integer(16)); + literals.put(new ANTLRHashString("write", this), new Integer(46)); + literals.put(new ANTLRHashString("regex", this), new Integer(34)); + literals.put(new ANTLRHashString("compare", this), new Integer(15)); + literals.put(new ANTLRHashString("entry", this), new Integer(20)); + literals.put(new ANTLRHashString("dnattr", this), new Integer(19)); + literals.put(new ANTLRHashString("manage", this), new Integer(27)); + literals.put(new ANTLRHashString("search", this), new Integer(36)); + literals.put(new ANTLRHashString("c", this), new Integer(13)); + literals.put(new ANTLRHashString("dn", this), new Integer(18)); + literals.put(new ANTLRHashString("users", this), new Integer(42)); + literals.put(new ANTLRHashString("attr", this), new Integer(6)); + literals.put(new ANTLRHashString("break", this), new Integer(11)); + literals.put(new ANTLRHashString("attrs", this), new Integer(7)); + literals.put(new ANTLRHashString("filter", this), new Integer(23)); + literals.put(new ANTLRHashString("sub", this), new Integer(39)); + literals.put(new ANTLRHashString("stop", this), new Integer(38)); + literals.put(new ANTLRHashString("val", this), new Integer(43)); + literals.put(new ANTLRHashString("level", this), new Integer(25)); + literals.put(new ANTLRHashString("by", this), new Integer(12)); + literals.put(new ANTLRHashString("children", this), new Integer(14)); +} + +public Token nextToken() throws TokenStreamException { + Token theRetToken=null; +tryAgain: + for (;;) { + Token _token = null; + int _ttype = Token.INVALID_TYPE; + resetText(); + try { // for char stream error handling + try { // for lexical error handling + switch ( LA(1)) { + case '0': case '1': case '2': case '3': + case '4': case '5': case '6': case '7': + case '8': case '9': + { + mINTEGER(true); + theRetToken=_returnToken; + break; + } + case '"': + { + mDOUBLE_QUOTED_STRING(true); + theRetToken=_returnToken; + break; + } + case '{': + { + mOPEN_CURLY(true); + theRetToken=_returnToken; + break; + } + case '}': + { + mCLOSE_CURLY(true); + theRetToken=_returnToken; + break; + } + case '\t': case '\n': case '\r': case ' ': + { + mSP(true); + theRetToken=_returnToken; + break; + } + case '=': + { + mEQUAL(true); + theRetToken=_returnToken; + break; + } + case '.': + { + mDOT(true); + theRetToken=_returnToken; + break; + } + case ',': + { + mSEP(true); + theRetToken=_returnToken; + break; + } + case '*': + { + mSTAR(true); + theRetToken=_returnToken; + break; + } + case '+': + { + mPLUS(true); + theRetToken=_returnToken; + break; + } + case '-': + { + mMINUS(true); + theRetToken=_returnToken; + break; + } + case '/': + { + mSLASH(true); + theRetToken=_returnToken; + break; + } + case '(': + { + mFILTER(true); + theRetToken=_returnToken; + break; + } + default: + if ((LA(1)=='t') && (LA(2)=='r') && (LA(3)=='a') && (LA(4)=='n') && (LA(5)=='s') && (LA(6)=='p') && (LA(7)=='o') && (LA(8)=='r') && (LA(9)=='t') && (LA(10)=='_')) { + mTRANSPORT_SSF(true); + theRetToken=_returnToken; + } + else if ((LA(1)=='s') && (LA(2)=='a') && (LA(3)=='s') && (LA(4)=='l') && (LA(5)=='_')) { + mSASL_SSF(true); + theRetToken=_returnToken; + } + else if ((LA(1)=='s') && (LA(2)=='s') && (LA(3)=='f') && (LA(4)=='=')) { + mSSF(true); + theRetToken=_returnToken; + } + else if ((LA(1)=='t') && (LA(2)=='l') && (LA(3)=='s') && (LA(4)=='_')) { + mTLS_SSF(true); + theRetToken=_returnToken; + } + else if (((LA(1) >= 'a' && LA(1) <= 'z')) && (true) && (true) && (true) && (true) && (true) && (true) && (true) && (true) && (true)) { + mIDENT(true); + theRetToken=_returnToken; + } + else { + if (LA(1)==EOF_CHAR) {uponEOF(); _returnToken = makeToken(Token.EOF_TYPE);} + else {throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());} + } + } + if ( _returnToken==null ) continue tryAgain; // found SKIP token + _ttype = _returnToken.getType(); + _ttype = testLiteralsTable(_ttype); + _returnToken.setType(_ttype); + return _returnToken; + } + catch (RecognitionException e) { + throw new TokenStreamRecognitionException(e); + } + } + catch (CharStreamException cse) { + if ( cse instanceof CharStreamIOException ) { + throw new TokenStreamIOException(((CharStreamIOException)cse).io); + } + else { + throw new TokenStreamException(cse.getMessage()); + } + } + } +} + + protected final void mDIGIT(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException { + int _ttype; Token _token=null; int _begin=text.length(); + _ttype = DIGIT; + int _saveIndex; + + switch ( LA(1)) { + case '0': + { + match('0'); + break; + } + case '1': case '2': case '3': case '4': + case '5': case '6': case '7': case '8': + case '9': + { + mLDIGIT(false); + break; + } + default: + { + throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn()); + } + } + if ( _createToken && _token==null && _ttype!=Token.SKIP ) { + _token = makeToken(_ttype); + _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin)); + } + _returnToken = _token; + } + + protected final void mLDIGIT(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException { + int _ttype; Token _token=null; int _begin=text.length(); + _ttype = LDIGIT; + int _saveIndex; + + matchRange('1','9'); + if ( _createToken && _token==null && _ttype!=Token.SKIP ) { + _token = makeToken(_ttype); + _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin)); + } + _returnToken = _token; + } + + public final void mINTEGER(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException { + int _ttype; Token _token=null; int _begin=text.length(); + _ttype = INTEGER; + int _saveIndex; + + if (((LA(1) >= '1' && LA(1) <= '9')) && ((LA(2) >= '0' && LA(2) <= '9'))) { + { + mLDIGIT(false); + { + int _cnt6=0; + _loop6: + do { + if (((LA(1) >= '0' && LA(1) <= '9'))) { + mDIGIT(false); + } + else { + if ( _cnt6>=1 ) { break _loop6; } else {throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());} + } + + _cnt6++; + } while (true); + } + } + } + else if (((LA(1) >= '0' && LA(1) <= '9')) && (true)) { + mDIGIT(false); + } + else { + throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn()); + } + + if ( _createToken && _token==null && _ttype!=Token.SKIP ) { + _token = makeToken(_ttype); + _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin)); + } + _returnToken = _token; + } + + public final void mDOUBLE_QUOTED_STRING(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException { + int _ttype; Token _token=null; int _begin=text.length(); + _ttype = DOUBLE_QUOTED_STRING; + int _saveIndex; + + _saveIndex=text.length(); + match('"'); + text.setLength(_saveIndex); + { + _loop9: + do { + if ((_tokenSet_0.member(LA(1)))) { + matchNot('"'); + } + else { + break _loop9; + } + + } while (true); + } + _saveIndex=text.length(); + match('"'); + text.setLength(_saveIndex); + if ( _createToken && _token==null && _ttype!=Token.SKIP ) { + _token = makeToken(_ttype); + _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin)); + } + _returnToken = _token; + } + + public final void mIDENT(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException { + int _ttype; Token _token=null; int _begin=text.length(); + _ttype = IDENT; + int _saveIndex; + + { + matchRange('a','z'); + } + { + _loop13: + do { + switch ( LA(1)) { + case 'a': case 'b': case 'c': case 'd': + case 'e': case 'f': case 'g': case 'h': + case 'i': case 'j': case 'k': case 'l': + case 'm': case 'n': case 'o': case 'p': + case 'q': case 'r': case 's': case 't': + case 'u': case 'v': case 'w': case 'x': + case 'y': case 'z': + { + matchRange('a','z'); + break; + } + case '0': case '1': case '2': case '3': + case '4': case '5': case '6': case '7': + case '8': case '9': + { + mDIGIT(false); + break; + } + case '-': + { + match('-'); + break; + } + default: + { + break _loop13; + } + } + } while (true); + } + if ( _createToken && _token==null && _ttype!=Token.SKIP ) { + _token = makeToken(_ttype); + _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin)); + } + _returnToken = _token; + } + + public final void mOPEN_CURLY(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException { + int _ttype; Token _token=null; int _begin=text.length(); + _ttype = OPEN_CURLY; + int _saveIndex; + + match('{'); + if ( _createToken && _token==null && _ttype!=Token.SKIP ) { + _token = makeToken(_ttype); + _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin)); + } + _returnToken = _token; + } + + public final void mCLOSE_CURLY(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException { + int _ttype; Token _token=null; int _begin=text.length(); + _ttype = CLOSE_CURLY; + int _saveIndex; + + match('}'); + if ( _createToken && _token==null && _ttype!=Token.SKIP ) { + _token = makeToken(_ttype); + _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin)); + } + _returnToken = _token; + } + + public final void mSP(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException { + int _ttype; Token _token=null; int _begin=text.length(); + _ttype = SP; + int _saveIndex; + + { + int _cnt18=0; + _loop18: + do { + if ((LA(1)==' ') && (true) && (true) && (true) && (true) && (true) && (true) && (true) && (true) && (true)) { + match(' '); + } + else if ((LA(1)=='\t') && (true) && (true) && (true) && (true) && (true) && (true) && (true) && (true) && (true)) { + match('\t'); + } + else if ((LA(1)=='\n') && (true) && (true) && (true) && (true) && (true) && (true) && (true) && (true) && (true)) { + match('\n'); + newline(); + } + else if ((LA(1)=='\r') && (true) && (true) && (true) && (true) && (true) && (true) && (true) && (true) && (true)) { + match('\r'); + } + else { + if ( _cnt18>=1 ) { break _loop18; } else {throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());} + } + + _cnt18++; + } while (true); + } + if ( _createToken && _token==null && _ttype!=Token.SKIP ) { + _token = makeToken(_ttype); + _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin)); + } + _returnToken = _token; + } + + public final void mSSF(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException { + int _ttype; Token _token=null; int _begin=text.length(); + _ttype = SSF; + int _saveIndex; + Token strength=null; + + match("ssf"); + mEQUAL(false); + mINTEGER(true); + strength=_returnToken; + setText( strength.getText() ); + if ( _createToken && _token==null && _ttype!=Token.SKIP ) { + _token = makeToken(_ttype); + _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin)); + } + _returnToken = _token; + } + + public final void mEQUAL(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException { + int _ttype; Token _token=null; int _begin=text.length(); + _ttype = EQUAL; + int _saveIndex; + + match('='); + if ( _createToken && _token==null && _ttype!=Token.SKIP ) { + _token = makeToken(_ttype); + _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin)); + } + _returnToken = _token; + } + + public final void mTRANSPORT_SSF(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException { + int _ttype; Token _token=null; int _begin=text.length(); + _ttype = TRANSPORT_SSF; + int _saveIndex; + Token strength=null; + + match("transport_ssf"); + mEQUAL(false); + mINTEGER(true); + strength=_returnToken; + setText( strength.getText() ); + if ( _createToken && _token==null && _ttype!=Token.SKIP ) { + _token = makeToken(_ttype); + _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin)); + } + _returnToken = _token; + } + + public final void mTLS_SSF(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException { + int _ttype; Token _token=null; int _begin=text.length(); + _ttype = TLS_SSF; + int _saveIndex; + Token strength=null; + + match("tls_ssf"); + mEQUAL(false); + mINTEGER(true); + strength=_returnToken; + setText( strength.getText() ); + if ( _createToken && _token==null && _ttype!=Token.SKIP ) { + _token = makeToken(_ttype); + _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin)); + } + _returnToken = _token; + } + + public final void mSASL_SSF(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException { + int _ttype; Token _token=null; int _begin=text.length(); + _ttype = SASL_SSF; + int _saveIndex; + Token strength=null; + + match("sasl_ssf"); + mEQUAL(false); + mINTEGER(true); + strength=_returnToken; + setText( strength.getText() ); + if ( _createToken && _token==null && _ttype!=Token.SKIP ) { + _token = makeToken(_ttype); + _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin)); + } + _returnToken = _token; + } + + public final void mDOT(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException { + int _ttype; Token _token=null; int _begin=text.length(); + _ttype = DOT; + int _saveIndex; + + match('.'); + if ( _createToken && _token==null && _ttype!=Token.SKIP ) { + _token = makeToken(_ttype); + _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin)); + } + _returnToken = _token; + } + + public final void mSEP(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException { + int _ttype; Token _token=null; int _begin=text.length(); + _ttype = SEP; + int _saveIndex; + + match(','); + if ( _createToken && _token==null && _ttype!=Token.SKIP ) { + _token = makeToken(_ttype); + _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin)); + } + _returnToken = _token; + } + + public final void mSTAR(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException { + int _ttype; Token _token=null; int _begin=text.length(); + _ttype = STAR; + int _saveIndex; + + match('*'); + if ( _createToken && _token==null && _ttype!=Token.SKIP ) { + _token = makeToken(_ttype); + _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin)); + } + _returnToken = _token; + } + + public final void mPLUS(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException { + int _ttype; Token _token=null; int _begin=text.length(); + _ttype = PLUS; + int _saveIndex; + + match('+'); + if ( _createToken && _token==null && _ttype!=Token.SKIP ) { + _token = makeToken(_ttype); + _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin)); + } + _returnToken = _token; + } + + public final void mMINUS(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException { + int _ttype; Token _token=null; int _begin=text.length(); + _ttype = MINUS; + int _saveIndex; + + match('-'); + if ( _createToken && _token==null && _ttype!=Token.SKIP ) { + _token = makeToken(_ttype); + _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin)); + } + _returnToken = _token; + } + + public final void mSLASH(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException { + int _ttype; Token _token=null; int _begin=text.length(); + _ttype = SLASH; + int _saveIndex; + + match('/'); + if ( _createToken && _token==null && _ttype!=Token.SKIP ) { + _token = makeToken(_ttype); + _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin)); + } + _returnToken = _token; + } + + public final void mFILTER(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException { + int _ttype; Token _token=null; int _begin=text.length(); + _ttype = FILTER; + int _saveIndex; + + match('('); + { + if ((_tokenSet_1.member(LA(1))) && (_tokenSet_2.member(LA(2))) && ((LA(3) >= '\u0000' && LA(3) <= '\u00ff')) && (true) && (true) && (true) && (true) && (true) && (true) && (true)) { + mSP(false); + } + else if ((_tokenSet_2.member(LA(1))) && ((LA(2) >= '\u0000' && LA(2) <= '\u00ff')) && (true) && (true) && (true) && (true) && (true) && (true) && (true) && (true)) { + } + else { + throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn()); + } + + } + { + switch ( LA(1)) { + case '&': + { + { + match('&'); + { + switch ( LA(1)) { + case '\t': case '\n': case '\r': case ' ': + { + mSP(false); + break; + } + case '(': + { + break; + } + default: + { + throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn()); + } + } + } + { + int _cnt36=0; + _loop36: + do { + if ((LA(1)=='(')) { + mFILTER(false); + } + else { + if ( _cnt36>=1 ) { break _loop36; } else {throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());} + } + + _cnt36++; + } while (true); + } + } + break; + } + case '|': + { + { + match('|'); + { + switch ( LA(1)) { + case '\t': case '\n': case '\r': case ' ': + { + mSP(false); + break; + } + case '(': + { + break; + } + default: + { + throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn()); + } + } + } + { + int _cnt40=0; + _loop40: + do { + if ((LA(1)=='(')) { + mFILTER(false); + } + else { + if ( _cnt40>=1 ) { break _loop40; } else {throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());} + } + + _cnt40++; + } while (true); + } + } + break; + } + case '!': + { + { + match('!'); + { + switch ( LA(1)) { + case '\t': case '\n': case '\r': case ' ': + { + mSP(false); + break; + } + case '(': + { + break; + } + default: + { + throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn()); + } + } + } + mFILTER(false); + } + break; + } + default: + if ((_tokenSet_3.member(LA(1)))) { + mFILTER_VALUE(false); + } + else { + throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn()); + } + } + } + { + switch ( LA(1)) { + case '\t': case '\n': case '\r': case ' ': + { + mSP(false); + break; + } + case ')': + { + break; + } + default: + { + throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn()); + } + } + } + match(')'); + if ( _createToken && _token==null && _ttype!=Token.SKIP ) { + _token = makeToken(_ttype); + _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin)); + } + _returnToken = _token; + } + + protected final void mFILTER_VALUE(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException { + int _ttype; Token _token=null; int _begin=text.length(); + _ttype = FILTER_VALUE; + int _saveIndex; + + { + { + match(_tokenSet_3); + } + { + _loop49: + do { + if ((_tokenSet_4.member(LA(1))) && ((LA(2) >= '\u0000' && LA(2) <= '\u00ff')) && (true) && (true) && (true) && (true) && (true) && (true) && (true) && (true)) { + { + match(_tokenSet_4); + } + } + else { + break _loop49; + } + + } while (true); + } + } + if ( _createToken && _token==null && _ttype!=Token.SKIP ) { + _token = makeToken(_ttype); + _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin)); + } + _returnToken = _token; + } + + + private static final long[] mk_tokenSet_0() { + long[] data = new long[8]; + data[0]=-17179869185L; + for (int i = 1; i<=3; i++) { data[i]=-1L; } + return data; + } + public static final BitSet _tokenSet_0 = new BitSet(mk_tokenSet_0()); + private static final long[] mk_tokenSet_1() { + long[] data = { 4294977024L, 0L, 0L, 0L, 0L}; + return data; + } + public static final BitSet _tokenSet_1 = new BitSet(mk_tokenSet_1()); + private static final long[] mk_tokenSet_2() { + long[] data = new long[8]; + data[0]=-3298534883329L; + for (int i = 1; i<=3; i++) { data[i]=-1L; } + return data; + } + public static final BitSet _tokenSet_2 = new BitSet(mk_tokenSet_2()); + private static final long[] mk_tokenSet_3() { + long[] data = new long[8]; + data[0]=-3582002724865L; + data[1]=-1152921504606846977L; + for (int i = 2; i<=3; i++) { data[i]=-1L; } + return data; + } + public static final BitSet _tokenSet_3 = new BitSet(mk_tokenSet_3()); + private static final long[] mk_tokenSet_4() { + long[] data = new long[8]; + data[0]=-2199023255553L; + for (int i = 1; i<=3; i++) { data[i]=-1L; } + return data; + } + public static final BitSet _tokenSet_4 = new BitSet(mk_tokenSet_4()); + + } diff --git a/plugins/openldap.acl.editor/src/main/java/org/apache/directory/studio/openldap/config/acl/model/AntlrAclLexer.smap b/plugins/openldap.acl.editor/src/main/java/org/apache/directory/studio/openldap/config/acl/model/AntlrAclLexer.smap new file mode 100644 index 0000000000..e695ebcb3b --- /dev/null +++ b/plugins/openldap.acl.editor/src/main/java/org/apache/directory/studio/openldap/config/acl/model/AntlrAclLexer.smap @@ -0,0 +1,480 @@ +SMAP +AntlrAclLexer.java +G +*S G +*F ++ 0 Acl.g +Acl.g +*L +0:116 +0:122 +0:128 +0:134 +0:140 +0:146 +0:152 +0:158 +0:164 +0:170 +0:176 +0:182 +0:188 +0:194 +0:198 +0:202 +0:206 +0:210 +21:4 +21:6 +21:7 +21:9 +21:10 +21:12 +107:239 +107:240 +107:241 +107:242 +107:244 +107:245 +107:246 +107:247 +107:250 +107:251 +107:252 +107:253 +107:254 +107:257 +107:258 +107:259 +107:260 +107:261 +107:262 +107:263 +107:264 +107:265 +107:266 +107:267 +109:269 +109:270 +109:271 +109:272 +109:274 +109:275 +109:276 +109:277 +109:278 +109:279 +109:280 +111:282 +111:283 +111:284 +111:285 +111:287 +111:289 +111:291 +111:292 +111:293 +111:294 +111:295 +111:296 +111:297 +111:298 +111:299 +111:301 +111:302 +111:303 +111:305 +111:306 +111:307 +111:308 +111:309 +111:310 +111:311 +111:313 +111:314 +111:315 +111:316 +111:317 +111:318 +113:320 +113:321 +113:322 +113:323 +113:325 +113:326 +113:327 +113:328 +113:329 +113:330 +113:331 +113:332 +113:333 +113:334 +113:335 +113:336 +113:338 +113:339 +113:340 +113:341 +113:342 +113:343 +113:344 +113:345 +113:346 +113:347 +113:348 +117:350 +117:351 +117:352 +117:353 +117:356 +117:358 +117:359 +117:360 +117:361 +117:362 +117:363 +117:364 +117:365 +117:366 +117:367 +117:368 +117:369 +117:370 +117:373 +117:374 +117:375 +117:376 +117:377 +117:380 +117:381 +117:382 +117:385 +117:386 +117:387 +117:388 +117:389 +117:390 +117:391 +117:392 +117:393 +117:394 +117:395 +117:396 +117:397 +119:399 +119:400 +119:401 +119:402 +119:404 +119:405 +119:406 +119:407 +119:408 +119:409 +119:410 +121:412 +121:413 +121:414 +121:415 +121:417 +121:418 +121:419 +121:420 +121:421 +121:422 +121:423 +123:425 +123:426 +123:427 +123:428 +123:431 +123:432 +123:433 +123:434 +123:435 +123:436 +123:437 +123:438 +123:439 +123:440 +123:441 +123:442 +123:443 +123:444 +123:445 +123:446 +123:447 +123:448 +123:449 +123:451 +123:452 +123:453 +123:454 +123:455 +123:456 +123:457 +123:458 +123:459 +125:461 +125:462 +125:463 +125:464 +125:465 +125:467 +125:468 +125:469 +125:470 +125:471 +125:472 +125:473 +125:474 +125:475 +125:476 +125:477 +127:492 +127:493 +127:494 +127:495 +127:496 +127:498 +127:499 +127:500 +127:501 +127:502 +127:503 +127:504 +127:505 +127:506 +127:507 +127:508 +129:510 +129:511 +129:512 +129:513 +129:514 +129:516 +129:517 +129:518 +129:519 +129:520 +129:521 +129:522 +129:523 +129:524 +129:525 +129:526 +131:528 +131:529 +131:530 +131:531 +131:532 +131:534 +131:535 +131:536 +131:537 +131:538 +131:539 +131:540 +131:541 +131:542 +131:543 +131:544 +133:546 +133:547 +133:548 +133:549 +133:551 +133:552 +133:553 +133:554 +133:555 +133:556 +133:557 +135:559 +135:560 +135:561 +135:562 +135:564 +135:565 +135:566 +135:567 +135:568 +135:569 +135:570 +137:479 +137:480 +137:481 +137:482 +137:484 +137:485 +137:486 +137:487 +137:488 +137:489 +137:490 +139:572 +139:573 +139:574 +139:575 +139:577 +139:578 +139:579 +139:580 +139:581 +139:582 +139:583 +141:585 +141:586 +141:587 +141:588 +141:590 +141:591 +141:592 +141:593 +141:594 +141:595 +141:596 +143:598 +143:599 +143:600 +143:601 +143:603 +143:604 +143:605 +143:606 +143:607 +143:608 +143:609 +145:611 +145:612 +145:613 +145:614 +145:616 +145:617 +145:618 +145:619 +145:620 +145:621 +145:622 +147:624 +147:625 +147:626 +147:627 +147:629 +147:631 +147:632 +147:633 +147:635 +147:636 +147:637 +147:638 +147:642 +147:643 +147:644 +147:646 +147:648 +147:649 +147:650 +147:651 +147:658 +147:659 +147:660 +147:661 +147:662 +147:665 +147:666 +147:667 +147:668 +147:669 +147:670 +147:671 +147:672 +147:673 +147:675 +147:676 +147:677 +147:681 +147:682 +147:684 +147:686 +147:687 +147:688 +147:689 +147:696 +147:697 +147:698 +147:699 +147:700 +147:703 +147:704 +147:705 +147:706 +147:707 +147:708 +147:709 +147:710 +147:711 +147:713 +147:714 +147:715 +147:719 +147:720 +147:722 +147:724 +147:725 +147:726 +147:727 +147:734 +147:735 +147:736 +147:737 +147:738 +147:740 +147:744 +147:745 +147:746 +147:747 +147:748 +147:749 +147:750 +147:751 +147:754 +147:755 +147:756 +147:757 +147:764 +147:765 +147:766 +147:767 +147:768 +147:770 +147:771 +147:772 +147:773 +147:774 +147:775 +147:776 +149:778 +149:779 +149:780 +149:781 +149:785 +149:787 +149:788 +149:789 +149:790 +149:792 +149:794 +149:795 +149:796 +149:797 +149:799 +149:800 +149:802 +149:803 +149:804 +149:805 +149:806 +149:807 +*E diff --git a/plugins/openldap.acl.editor/src/main/java/org/apache/directory/studio/openldap/config/acl/model/AntlrAclLexerTokenTypes.java b/plugins/openldap.acl.editor/src/main/java/org/apache/directory/studio/openldap/config/acl/model/AntlrAclLexerTokenTypes.java new file mode 100644 index 0000000000..df3a559755 --- /dev/null +++ b/plugins/openldap.acl.editor/src/main/java/org/apache/directory/studio/openldap/config/acl/model/AntlrAclLexerTokenTypes.java @@ -0,0 +1,83 @@ +// $ANTLR 2.7.7 (20060906): "Acl.g" -> "AntlrAclLexer.java"$ + + +package org.apache.directory.studio.openldap.config.acl.model; + +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import org.apache.directory.api.ldap.model.name.Dn; +import org.apache.directory.api.ldap.model.exception.LdapInvalidDnException; + +import java.util.List; + +public interface AntlrAclLexerTokenTypes { + int EOF = 1; + int NULL_TREE_LOOKAHEAD = 3; + int ID_access = 4; + int ID_anonymous = 5; + int ID_attr = 6; + int ID_attrs = 7; + int ID_auth = 8; + int ID_base = 9; + int ID_base_object = 10; + int ID_break = 11; + int ID_by = 12; + int ID_c = 13; + int ID_children = 14; + int ID_compare = 15; + int ID_continue = 16; + int ID_disclose = 17; + int ID_dn = 18; + int ID_dnattr = 19; + int ID_entry = 20; + int ID_exact = 21; + int ID_expand = 22; + int ID_filter = 23; + int ID_group = 24; + int ID_level = 25; + int ID_m = 26; + int ID_manage = 27; + int ID_matchingRule = 28; + int ID_none = 29; + int ID_one = 30; + int ID_one_level = 31; + int ID_r = 32; + int ID_read = 33; + int ID_regex = 34; + int ID_s = 35; + int ID_search = 36; + int ID_self = 37; + int ID_stop = 38; + int ID_sub = 39; + int ID_subtree = 40; + int ID_to = 41; + int ID_users = 42; + int ID_val = 43; + int ID_w = 44; + int ID_x = 45; + int ID_write = 46; + int DIGIT = 47; + int LDIGIT = 48; + int INTEGER = 49; + int DOUBLE_QUOTED_STRING = 50; + int IDENT = 51; + int OPEN_CURLY = 52; + int CLOSE_CURLY = 53; + int SP = 54; + int SSF = 55; + int TRANSPORT_SSF = 56; + int TLS_SSF = 57; + int SASL_SSF = 58; + int DOT = 59; + int SEP = 60; + int EQUAL = 61; + int STAR = 62; + int PLUS = 63; + int MINUS = 64; + int SLASH = 65; + int FILTER = 66; + int FILTER_VALUE = 67; + int STRING = 68; + int REGEX = 69; +} diff --git a/plugins/openldap.acl.editor/src/main/java/org/apache/directory/studio/openldap/config/acl/model/AntlrAclLexerTokenTypes.txt b/plugins/openldap.acl.editor/src/main/java/org/apache/directory/studio/openldap/config/acl/model/AntlrAclLexerTokenTypes.txt new file mode 100644 index 0000000000..53352cf27e --- /dev/null +++ b/plugins/openldap.acl.editor/src/main/java/org/apache/directory/studio/openldap/config/acl/model/AntlrAclLexerTokenTypes.txt @@ -0,0 +1,68 @@ +// $ANTLR 2.7.7 (20060906): Acl.g -> AntlrAclLexerTokenTypes.txt$ +AntlrAclLexer // output token vocab name +ID_access="access"=4 +ID_anonymous="anonymous"=5 +ID_attr="attr"=6 +ID_attrs="attrs"=7 +ID_auth="auth"=8 +ID_base="base"=9 +ID_base_object="baseobject"=10 +ID_break="break"=11 +ID_by="by"=12 +ID_c="c"=13 +ID_children="children"=14 +ID_compare="compare"=15 +ID_continue="continue"=16 +ID_disclose="disclose"=17 +ID_dn="dn"=18 +ID_dnattr="dnattr"=19 +ID_entry="entry"=20 +ID_exact="exact"=21 +ID_expand="expand"=22 +ID_filter="filter"=23 +ID_group="group"=24 +ID_level="level"=25 +ID_m="m"=26 +ID_manage="manage"=27 +ID_matchingRule="matchingRule"=28 +ID_none="none"=29 +ID_one="one"=30 +ID_one_level="onelevel"=31 +ID_r="r"=32 +ID_read="read"=33 +ID_regex="regex"=34 +ID_s="s"=35 +ID_search="search"=36 +ID_self="self"=37 +ID_stop="stop"=38 +ID_sub="sub"=39 +ID_subtree="subtree"=40 +ID_to="to"=41 +ID_users="users"=42 +ID_val="val"=43 +ID_w="w"=44 +ID_x="x"=45 +ID_write="write"=46 +DIGIT=47 +LDIGIT=48 +INTEGER=49 +DOUBLE_QUOTED_STRING=50 +IDENT=51 +OPEN_CURLY=52 +CLOSE_CURLY=53 +SP=54 +SSF=55 +TRANSPORT_SSF=56 +TLS_SSF=57 +SASL_SSF=58 +DOT=59 +SEP=60 +EQUAL=61 +STAR=62 +PLUS=63 +MINUS=64 +SLASH=65 +FILTER=66 +FILTER_VALUE=67 +STRING=68 +REGEX=69 diff --git a/plugins/openldap.acl.editor/src/main/java/org/apache/directory/studio/openldap/config/acl/model/AntlrAclParser.java b/plugins/openldap.acl.editor/src/main/java/org/apache/directory/studio/openldap/config/acl/model/AntlrAclParser.java new file mode 100644 index 0000000000..4ea3a56cb7 --- /dev/null +++ b/plugins/openldap.acl.editor/src/main/java/org/apache/directory/studio/openldap/config/acl/model/AntlrAclParser.java @@ -0,0 +1,2225 @@ +// $ANTLR 2.7.7 (20060906): "Acl.g" -> "AntlrAclParser.java"$ + + +package org.apache.directory.studio.openldap.config.acl.model; + +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import org.apache.directory.api.ldap.model.name.Dn; +import org.apache.directory.api.ldap.model.exception.LdapInvalidDnException; + +import java.util.List; + +import antlr.TokenBuffer; +import antlr.TokenStreamException; +import antlr.TokenStreamIOException; +import antlr.ANTLRException; +import antlr.LLkParser; +import antlr.Token; +import antlr.TokenStream; +import antlr.RecognitionException; +import antlr.NoViableAltException; +import antlr.MismatchedTokenException; +import antlr.SemanticException; +import antlr.ParserSharedInputState; +import antlr.collections.impl.BitSet; + +/** + * The ANTLR generated OpenLDAP ACL parser. + */ +public class AntlrAclParser extends antlr.LLkParser implements AntlrAclLexerTokenTypes + { + + private static final Logger log = LoggerFactory.getLogger( AntlrAclParser.class ); + + private AclItem aclItem; + + public AclItem getAclItem() + { + return aclItem; + } + +protected AntlrAclParser(TokenBuffer tokenBuf, int k) { + super(tokenBuf,k); + tokenNames = _tokenNames; +} + +public AntlrAclParser(TokenBuffer tokenBuf) { + this(tokenBuf,2); +} + +protected AntlrAclParser(TokenStream lexer, int k) { + super(lexer,k); + tokenNames = _tokenNames; +} + +public AntlrAclParser(TokenStream lexer) { + this(lexer,2); +} + +public AntlrAclParser(ParserSharedInputState state) { + super(state,2); + tokenNames = _tokenNames; +} + + public final void parse() throws RecognitionException, TokenStreamException { + + + log.debug( "entered parse()" ); + System.out.println( "entered parse_init()" ); + + + { + if ((LA(1)==SP) && (LA(2)==ID_access||LA(2)==ID_to||LA(2)==SP)) { + match(SP); + } + else if ((LA(1)==ID_access||LA(1)==ID_to||LA(1)==SP) && (LA(2)==ID_to||LA(2)==SP)) { + } + else { + throw new NoViableAltException(LT(1), getFilename()); + } + + } + aclItem(); + { + switch ( LA(1)) { + case SP: + { + match(SP); + break; + } + case EOF: + { + break; + } + default: + { + throw new NoViableAltException(LT(1), getFilename()); + } + } + } + match(Token.EOF_TYPE); + } + + public final void aclItem() throws RecognitionException, TokenStreamException { + + + log.debug( "entered aclItem()" ); + System.out.println( "entered aclItem()" ); + + aclItem = new AclItem(); + + + { + switch ( LA(1)) { + case ID_access: + { + match(ID_access); + match(SP); + break; + } + case ID_to: + case SP: + { + break; + } + default: + { + throw new NoViableAltException(LT(1), getFilename()); + } + } + } + { + switch ( LA(1)) { + case SP: + { + match(SP); + break; + } + case ID_to: + { + break; + } + default: + { + throw new NoViableAltException(LT(1), getFilename()); + } + } + } + match(ID_to); + match(SP); + { + switch ( LA(1)) { + case ID_attr: + case ID_attrs: + case ID_dn: + case ID_filter: + case STAR: + { + what(); + match(SP); + break; + } + case ID_by: + { + break; + } + default: + { + throw new NoViableAltException(LT(1), getFilename()); + } + } + } + { + int _cnt58=0; + _loop58: + do { + if ((LA(1)==ID_by)) { + match(ID_by); + match(SP); + who(); + } + else { + if ( _cnt58>=1 ) { break _loop58; } else {throw new NoViableAltException(LT(1), getFilename());} + } + + _cnt58++; + } while (true); + } + + if ( aclItem.getWhatClause() == null ) + { + // The 'what' is equivalent to '*' + aclItem.setWhatClause( new AclWhatClauseStar() ); + } + + } + + public final void what() throws RecognitionException, TokenStreamException { + + + log.debug( "entered what()" ); + System.out.println( "entered what()" ); + + + { + switch ( LA(1)) { + case ID_dn: + { + match(ID_dn); + what_dn(); + break; + } + case ID_filter: + { + what_filter(); + break; + } + case ID_attr: + case ID_attrs: + { + what_attrs(); + break; + } + case STAR: + { + what_star(); + break; + } + default: + { + throw new NoViableAltException(LT(1), getFilename()); + } + } + } + } + + public final void who() throws RecognitionException, TokenStreamException { + + + log.debug( "entered who()" ); + + + { + switch ( LA(1)) { + case STAR: + { + who_star(); + break; + } + case ID_anonymous: + { + who_anonymous(); + break; + } + case ID_users: + { + who_users(); + break; + } + case ID_self: + { + who_self(); + break; + } + case ID_dn: + { + who_dn(); + break; + } + case ID_dnattr: + { + who_dnattr(); + break; + } + case ID_group: + { + who_group(); + break; + } + case SSF: + { + who_ssf(); + break; + } + case TRANSPORT_SSF: + { + who_transport_ssf(); + break; + } + case TLS_SSF: + { + who_tls_ssf(); + break; + } + case SASL_SSF: + { + who_sasl_ssf(); + break; + } + default: + { + throw new NoViableAltException(LT(1), getFilename()); + } + } + } + { + if ((LA(1)==SP) && (_tokenSet_0.member(LA(2)))) { + match(SP); + who_access_level(); + } + else if ((LA(1)==EOF||LA(1)==ID_by||LA(1)==SP) && (_tokenSet_1.member(LA(2)))) { + } + else { + throw new NoViableAltException(LT(1), getFilename()); + } + + } + { + if ((LA(1)==SP) && (LA(2)==ID_break||LA(2)==ID_continue||LA(2)==ID_stop)) { + match(SP); + who_control(); + } + else if ((LA(1)==EOF||LA(1)==ID_by||LA(1)==SP) && (LA(2)==EOF||LA(2)==SP)) { + } + else { + throw new NoViableAltException(LT(1), getFilename()); + } + + } + } + + public final void what_dn() throws RecognitionException, TokenStreamException { + + Token quoted_token = null; + Token string_token = null; + + log.debug( "entered what_dn()" ); + System.out.println( "entered what_dn()" ); + + + if ((LA(1)==DOT) && (LA(2)==ID_exact||LA(2)==ID_regex)) { + basic_dn_style(); + } + else if ((LA(1)==DOT) && (_tokenSet_2.member(LA(2)))) { + scope_dn_clause(); + } + else if ((LA(1)==SP||LA(1)==EQUAL)) { + { + switch ( LA(1)) { + case SP: + { + match(SP); + break; + } + case EQUAL: + { + break; + } + default: + { + throw new NoViableAltException(LT(1), getFilename()); + } + } + } + match(EQUAL); + { + switch ( LA(1)) { + case SP: + { + match(SP); + break; + } + case DOUBLE_QUOTED_STRING: + case STRING: + { + break; + } + default: + { + throw new NoViableAltException(LT(1), getFilename()); + } + } + } + { + switch ( LA(1)) { + case DOUBLE_QUOTED_STRING: + { + + System.out.println( "what-dn default" ); + + quoted_token = LT(1); + match(DOUBLE_QUOTED_STRING); + + AclWhatClauseDn whatClauseDn = new AclWhatClauseDn(); + String dnString = quoted_token.getText(); + + try + { + new Dn( dnString ); + } + catch ( LdapInvalidDnException lide ) + { + throw new RecognitionException( "The DN is invalid : " + dnString ); + } + + whatClauseDn.setPattern( dnString ); + aclItem.setWhatClause( whatClauseDn ); + + break; + } + case STRING: + { + string_token = LT(1); + match(STRING); + + AclWhatClauseDn whatClauseDn = new AclWhatClauseDn(); + String dnString = string_token.getText(); + + try + { + new Dn( dnString ); + } + catch ( LdapInvalidDnException lide ) + { + throw new RecognitionException( "The DN is invalid" + dnString ); + } + + whatClauseDn.setPattern( dnString ); + aclItem.setWhatClause( whatClauseDn ); + + break; + } + default: + { + throw new NoViableAltException(LT(1), getFilename()); + } + } + } + } + else { + throw new NoViableAltException(LT(1), getFilename()); + } + + } + + public final void what_filter() throws RecognitionException, TokenStreamException { + + Token token = null; + + log.debug( "entered what_filter()" ); + System.out.println( "entered what_filter()" ); + + AclWhatClauseFilter whatClauseFilter = new AclWhatClauseFilter(); + + + match(ID_filter); + { + switch ( LA(1)) { + case SP: + { + match(SP); + break; + } + case EQUAL: + { + break; + } + default: + { + throw new NoViableAltException(LT(1), getFilename()); + } + } + } + match(EQUAL); + { + switch ( LA(1)) { + case SP: + { + match(SP); + break; + } + case FILTER: + { + break; + } + default: + { + throw new NoViableAltException(LT(1), getFilename()); + } + } + } + token = LT(1); + match(FILTER); + + // TODO : check tah the filter is valid + whatClauseFilter.setFilter( token.getText() ); + + aclItem.setWhatClause( whatClauseFilter ); + + } + + public final void what_attrs() throws RecognitionException, TokenStreamException { + + + log.debug( "entered what_attrs()" ); + System.out.println( "entered what_attrs()" ); + + //AclWhatClauseAttributes whatClauseAttributes = new AclWhatClauseAttributess(); + + + { + switch ( LA(1)) { + case ID_attrs: + { + match(ID_attrs); + break; + } + case ID_attr: + { + match(ID_attr); + break; + } + default: + { + throw new NoViableAltException(LT(1), getFilename()); + } + } + } + { + switch ( LA(1)) { + case SP: + { + match(SP); + break; + } + case EQUAL: + { + break; + } + default: + { + throw new NoViableAltException(LT(1), getFilename()); + } + } + } + match(EQUAL); + { + switch ( LA(1)) { + case SP: + { + match(SP); + break; + } + case ID_children: + case ID_entry: + case IDENT: + { + break; + } + default: + { + throw new NoViableAltException(LT(1), getFilename()); + } + } + } + what_attrs_list(); + } + + public final void what_star() throws RecognitionException, TokenStreamException { + + + log.debug( "entered what_star()" ); + System.out.println( "entered what_star()" ); + + + match(STAR); + + aclItem.setWhatClause( new AclWhatClauseStar() ); + + } + + public final void basic_dn_style() throws RecognitionException, TokenStreamException { + + + log.debug( "entered basic_dn_style()" ); + System.out.println( "entered basic_dn_style()" ); + + + if ((LA(1)==DOT) && (LA(2)==ID_exact)) { + exact_basic_dn_style(); + } + else if ((LA(1)==DOT) && (LA(2)==ID_regex)) { + regex_basic_dn_style(); + } + else { + throw new NoViableAltException(LT(1), getFilename()); + } + + } + + public final void scope_dn_clause() throws RecognitionException, TokenStreamException { + + Token quoted_token = null; + Token string_token = null; + + log.debug( "entered scope_dn_clause()" ); + System.out.println( "entered scope_dn_clause()" ); + AclWhatClauseDn whatClauseDn = new AclWhatClauseDn(); + + + scope_dn_style(whatClauseDn); + { + switch ( LA(1)) { + case SP: + { + match(SP); + break; + } + case EQUAL: + { + break; + } + default: + { + throw new NoViableAltException(LT(1), getFilename()); + } + } + } + match(EQUAL); + { + switch ( LA(1)) { + case SP: + { + match(SP); + break; + } + case DOUBLE_QUOTED_STRING: + case STRING: + { + break; + } + default: + { + throw new NoViableAltException(LT(1), getFilename()); + } + } + } + { + switch ( LA(1)) { + case DOUBLE_QUOTED_STRING: + { + quoted_token = LT(1); + match(DOUBLE_QUOTED_STRING); + + whatClauseDn.setPattern( quoted_token.getText() ); + + break; + } + case STRING: + { + string_token = LT(1); + match(STRING); + + whatClauseDn.setPattern( string_token.getText() ); + + break; + } + default: + { + throw new NoViableAltException(LT(1), getFilename()); + } + } + } + + aclItem.setWhatClause( whatClauseDn ); + + } + + public final void exact_basic_dn_style() throws RecognitionException, TokenStreamException { + + Token quoted_token = null; + Token string_token = null; + + log.debug( "entered exact_basic_dn_style()" ); + System.out.println( "entered basic_dn_style()" ); + AclWhatClauseDn whatClauseDn = new AclWhatClauseDn(); + whatClauseDn.setType( AclWhatClauseDnTypeEnum.EXACT ); + + + match(DOT); + { + match(ID_exact); + { + switch ( LA(1)) { + case SP: + { + match(SP); + break; + } + case EQUAL: + { + break; + } + default: + { + throw new NoViableAltException(LT(1), getFilename()); + } + } + } + match(EQUAL); + { + switch ( LA(1)) { + case SP: + { + match(SP); + break; + } + case DOUBLE_QUOTED_STRING: + case STRING: + { + break; + } + default: + { + throw new NoViableAltException(LT(1), getFilename()); + } + } + } + { + switch ( LA(1)) { + case DOUBLE_QUOTED_STRING: + { + quoted_token = LT(1); + match(DOUBLE_QUOTED_STRING); + + String dnString = quoted_token.getText(); + + try + { + new Dn( dnString ); + } + catch ( LdapInvalidDnException lide ) + { + throw new RecognitionException( "The DN is invalid" + dnString ); + } + + whatClauseDn.setPattern( dnString ); + + break; + } + case STRING: + { + string_token = LT(1); + match(STRING); + + String dnString = string_token.getText(); + + try + { + new Dn( dnString ); + } + catch ( LdapInvalidDnException lide ) + { + throw new RecognitionException( "The DN is invalid" + dnString ); + } + + whatClauseDn.setPattern( dnString ); + + break; + } + default: + { + throw new NoViableAltException(LT(1), getFilename()); + } + } + } + } + + aclItem.setWhatClause( whatClauseDn ); + + } + + public final void regex_basic_dn_style() throws RecognitionException, TokenStreamException { + + Token quoted_token = null; + Token string_token = null; + + log.debug( "entered regex_basic_dn_style()" ); + System.out.println( "entered regex_basic_dn_style()" ); + AclWhatClauseDn whatClauseDn = new AclWhatClauseDn(); + whatClauseDn.setType( AclWhatClauseDnTypeEnum.REGEX ); + + + match(DOT); + { + match(ID_regex); + { + switch ( LA(1)) { + case SP: + { + match(SP); + break; + } + case EQUAL: + { + break; + } + default: + { + throw new NoViableAltException(LT(1), getFilename()); + } + } + } + match(EQUAL); + { + switch ( LA(1)) { + case SP: + { + match(SP); + break; + } + case DOUBLE_QUOTED_STRING: + case STRING: + { + break; + } + default: + { + throw new NoViableAltException(LT(1), getFilename()); + } + } + } + + System.out.println( "In '='" ); + + { + switch ( LA(1)) { + case DOUBLE_QUOTED_STRING: + { + quoted_token = LT(1); + match(DOUBLE_QUOTED_STRING); + + whatClauseDn.setPattern( quoted_token.getText() ); + + break; + } + case STRING: + { + string_token = LT(1); + match(STRING); + + whatClauseDn.setPattern( string_token.getText() ); + + break; + } + default: + { + throw new NoViableAltException(LT(1), getFilename()); + } + } + } + } + + aclItem.setWhatClause( whatClauseDn ); + + } + + public final void scope_dn_style( + AclWhatClauseDn whatClauseDn + ) throws RecognitionException, TokenStreamException { + + + log.debug( "entered scope_dn_style()" ); + System.out.println( "entered scope_dn_style()" ); + + + match(DOT); + { + switch ( LA(1)) { + case ID_base: + { + match(ID_base); + + whatClauseDn.setType( AclWhatClauseDnTypeEnum.BASE ); + + break; + } + case ID_base_object: + { + match(ID_base_object); + + whatClauseDn.setType( AclWhatClauseDnTypeEnum.BASE_OBJECT ); + + break; + } + case ID_one: + { + match(ID_one); + + whatClauseDn.setType( AclWhatClauseDnTypeEnum.ONE ); + + break; + } + case ID_one_level: + { + match(ID_one_level); + + whatClauseDn.setType( AclWhatClauseDnTypeEnum.ONE_LEVEL ); + + break; + } + case ID_sub: + { + match(ID_sub); + + whatClauseDn.setType( AclWhatClauseDnTypeEnum.SUB ); + + break; + } + case ID_subtree: + { + match(ID_subtree); + + whatClauseDn.setType( AclWhatClauseDnTypeEnum.SUBTREE ); + + break; + } + case ID_children: + { + match(ID_children); + + whatClauseDn.setType( AclWhatClauseDnTypeEnum.CHILDREN ); + + break; + } + default: + { + throw new NoViableAltException(LT(1), getFilename()); + } + } + } + } + + public final void what_attrs_list() throws RecognitionException, TokenStreamException { + + Token attribute = null; + + log.debug( "entered what_attrs_list()" ); + System.out.println( "entered what_attrs_list()" ); + + + + { + switch ( LA(1)) { + case IDENT: + { + attribute = LT(1); + match(IDENT); + { + switch ( LA(1)) { + case SP: + { + { + if ((LA(1)==SP) && (LA(2)==ID_val)) { + attr_val(); + } + else if ((LA(1)==SP) && (LA(2)==ID_by)) { + } + else { + throw new NoViableAltException(LT(1), getFilename()); + } + + } + break; + } + case SEP: + { + match(SEP); + attr_list(); + break; + } + default: + { + throw new NoViableAltException(LT(1), getFilename()); + } + } + } + + // We are not allowed to have more than one attribute + // if we have a val + + break; + } + case ID_entry: + { + match(ID_entry); + break; + } + case ID_children: + { + match(ID_children); + break; + } + default: + { + throw new NoViableAltException(LT(1), getFilename()); + } + } + } + } + + public final void attr_val() throws RecognitionException, TokenStreamException { + + + log.debug( "entered what_attrs_list()" ); + System.out.println( "entered what_attrs_list()" ); + + + match(SP); + match(ID_val); + { + switch ( LA(1)) { + case SLASH: + { + matching_rule(); + break; + } + case SP: + case DOT: + case EQUAL: + { + break; + } + default: + { + throw new NoViableAltException(LT(1), getFilename()); + } + } + } + { + switch ( LA(1)) { + case DOT: + { + attr_val_style(); + break; + } + case SP: + case EQUAL: + { + break; + } + default: + { + throw new NoViableAltException(LT(1), getFilename()); + } + } + } + { + switch ( LA(1)) { + case SP: + { + match(SP); + break; + } + case EQUAL: + { + break; + } + default: + { + throw new NoViableAltException(LT(1), getFilename()); + } + } + } + match(EQUAL); + { + switch ( LA(1)) { + case SP: + { + match(SP); + break; + } + case REGEX: + { + break; + } + default: + { + throw new NoViableAltException(LT(1), getFilename()); + } + } + } + match(REGEX); + } + + public final void attr_list() throws RecognitionException, TokenStreamException { + + + log.debug( "entered attr_list()" ); + System.out.println( "entered attr_list()" ); + + + { + switch ( LA(1)) { + case IDENT: + { + match(IDENT); + break; + } + case ID_entry: + { + match(ID_entry); + break; + } + case ID_children: + { + match(ID_children); + break; + } + default: + { + throw new NoViableAltException(LT(1), getFilename()); + } + } + } + { + _loop105: + do { + if ((LA(1)==SEP) && (LA(2)==ID_children||LA(2)==ID_entry||LA(2)==IDENT)) { + match(SEP); + attr_list(); + } + else { + break _loop105; + } + + } while (true); + } + } + + public final void matching_rule() throws RecognitionException, TokenStreamException { + + + log.debug( "entered matching_rule()" ); + System.out.println( "entered matching_rule()" ); + + + match(SLASH); + match(IDENT); + } + + public final void attr_val_style() throws RecognitionException, TokenStreamException { + + + log.debug( "entered attr_val_style()" ); + System.out.println( "entered attr_val_style()" ); + + + match(DOT); + { + switch ( LA(1)) { + case ID_exact: + { + match(ID_exact); + + //whatClauseAttributes.setStyle( AclAttributeStyleEnum.EXACT ); + + break; + } + case ID_base: + { + match(ID_base); + + //whatClauseAttributes.setStyle( AclAttributeStyleEnum.BASE ); + + break; + } + case ID_base_object: + { + match(ID_base_object); + + //whatClauseAttributes.setStyle( AclAttributeStyleEnum.BASE_OBJECT ); + + break; + } + case ID_regex: + { + match(ID_regex); + + //whatClauseAttributes.setStyle( AclAttributeStyleEnum.REGEX ); + + break; + } + default: + { + throw new NoViableAltException(LT(1), getFilename()); + } + } + } + } + + public final void who_star() throws RecognitionException, TokenStreamException { + + + log.debug( "entered who_star()" ); + + + match(STAR); + + aclItem.addWhoClause( new AclWhoClauseStar() ); + + } + + public final void who_anonymous() throws RecognitionException, TokenStreamException { + + + log.debug( "entered who_anonymous()" ); + + + match(ID_anonymous); + + aclItem.addWhoClause( new AclWhoClauseAnonymous() ); + + } + + public final void who_users() throws RecognitionException, TokenStreamException { + + + log.debug( "entered who_users()" ); + + + match(ID_users); + + aclItem.addWhoClause( new AclWhoClauseUsers() ); + + } + + public final void who_self() throws RecognitionException, TokenStreamException { + + + log.debug( "entered who_self()" ); + + + match(ID_self); + + aclItem.addWhoClause( new AclWhoClauseSelf() ); + + } + + public final void who_dn() throws RecognitionException, TokenStreamException { + + Token token = null; + + log.debug( "entered who_dn()" ); + + AclWhoClauseDn whoClauseDn = new AclWhoClauseDn(); + aclItem.addWhoClause( whoClauseDn ); + + + match(ID_dn); + { + switch ( LA(1)) { + case DOT: + { + match(DOT); + who_dn_type(); + { + switch ( LA(1)) { + case SEP: + { + match(SEP); + who_dn_modifier(); + break; + } + case SP: + case EQUAL: + { + break; + } + default: + { + throw new NoViableAltException(LT(1), getFilename()); + } + } + } + break; + } + case SP: + case EQUAL: + { + break; + } + default: + { + throw new NoViableAltException(LT(1), getFilename()); + } + } + } + { + switch ( LA(1)) { + case SP: + { + match(SP); + break; + } + case EQUAL: + { + break; + } + default: + { + throw new NoViableAltException(LT(1), getFilename()); + } + } + } + match(EQUAL); + { + switch ( LA(1)) { + case SP: + { + match(SP); + break; + } + case DOUBLE_QUOTED_STRING: + { + break; + } + default: + { + throw new NoViableAltException(LT(1), getFilename()); + } + } + } + token = LT(1); + match(DOUBLE_QUOTED_STRING); + + whoClauseDn.setPattern( token.getText() ); + + } + + public final void who_dnattr() throws RecognitionException, TokenStreamException { + + Token token = null; + + log.debug( "entered who_dnattr()" ); + + AclWhoClauseDnAttr whoClauseDnAttr = new AclWhoClauseDnAttr(); + aclItem.addWhoClause( whoClauseDnAttr ); + + + match(ID_dnattr); + { + switch ( LA(1)) { + case SP: + { + match(SP); + break; + } + case EQUAL: + { + break; + } + default: + { + throw new NoViableAltException(LT(1), getFilename()); + } + } + } + match(EQUAL); + { + switch ( LA(1)) { + case SP: + { + match(SP); + break; + } + case IDENT: + { + break; + } + default: + { + throw new NoViableAltException(LT(1), getFilename()); + } + } + } + token = LT(1); + match(IDENT); + + whoClauseDnAttr.setAttribute( token.getText() ); + + } + + public final void who_group() throws RecognitionException, TokenStreamException { + + Token objectclass = null; + Token attrname = null; + Token pattern = null; + + log.debug( "entered who_group()" ); + + AclWhoClauseGroup whoClauseGroup = new AclWhoClauseGroup(); + aclItem.addWhoClause( whoClauseGroup ); + + + match(ID_group); + { + switch ( LA(1)) { + case SLASH: + { + match(SLASH); + objectclass = LT(1); + match(IDENT); + { + switch ( LA(1)) { + case SLASH: + { + match(SLASH); + attrname = LT(1); + match(IDENT); + break; + } + case DOT: + case EQUAL: + { + break; + } + default: + { + throw new NoViableAltException(LT(1), getFilename()); + } + } + } + break; + } + case DOT: + case EQUAL: + { + break; + } + default: + { + throw new NoViableAltException(LT(1), getFilename()); + } + } + } + { + switch ( LA(1)) { + case DOT: + { + match(DOT); + who_group_type(); + break; + } + case EQUAL: + { + break; + } + default: + { + throw new NoViableAltException(LT(1), getFilename()); + } + } + } + match(EQUAL); + pattern = LT(1); + match(DOUBLE_QUOTED_STRING); + + if ( objectclass != null ) + { + whoClauseGroup.setObjectclass( objectclass.getText() ); + } + + if ( attrname != null ) + { + whoClauseGroup.setAttribute( attrname.getText() ); + } + + if ( pattern != null ) + { + whoClauseGroup.setPattern( pattern.getText() ); + } + + } + + public final void who_ssf() throws RecognitionException, TokenStreamException { + + Token strength = null; + + log.debug( "entered who_ssf()" ); + + AclWhoClauseSsf whoClauseSsf = new AclWhoClauseSsf(); + aclItem.addWhoClause( whoClauseSsf ); + + + strength = LT(1); + match(SSF); + + whoClauseSsf.setStrength( Integer.valueOf( strength.getText() ) ); + + } + + public final void who_transport_ssf() throws RecognitionException, TokenStreamException { + + Token strength = null; + + log.debug( "entered who_transport_ssf()" ); + + AclWhoClauseTransportSsf whoClauseTransportSsf = new AclWhoClauseTransportSsf(); + aclItem.addWhoClause( whoClauseTransportSsf ); + + + strength = LT(1); + match(TRANSPORT_SSF); + + whoClauseTransportSsf.setStrength( Integer.valueOf( strength.getText() ) ); + + } + + public final void who_tls_ssf() throws RecognitionException, TokenStreamException { + + Token strength = null; + + log.debug( "entered who_tls_ssf()" ); + + AclWhoClauseTlsSsf whoClauseTlsSsf = new AclWhoClauseTlsSsf(); + aclItem.addWhoClause( whoClauseTlsSsf ); + + + strength = LT(1); + match(TLS_SSF); + + whoClauseTlsSsf.setStrength( Integer.valueOf( strength.getText() ) ); + + } + + public final void who_sasl_ssf() throws RecognitionException, TokenStreamException { + + Token strength = null; + + log.debug( "entered who_sasl_ssf()" ); + + AclWhoClauseSaslSsf whoClauseSaslSsf = new AclWhoClauseSaslSsf(); + aclItem.addWhoClause( whoClauseSaslSsf ); + + + strength = LT(1); + match(SASL_SSF); + + whoClauseSaslSsf.setStrength( Integer.valueOf( strength.getText() ) ); + + } + + public final void who_access_level() throws RecognitionException, TokenStreamException { + + + log.debug( "entered who_access_level()" ); + + List whoClauses = aclItem.getWhoClauses(); + + if ( whoClauses.size() == 0 ) + { + // Throw an exception ? + return; + } + + AclWhoClause whoClause = aclItem.getWhoClauses().get( whoClauses.size() - 1 ); + AclAccessLevel accessLevel = new AclAccessLevel(); + whoClause.setAccessLevel( accessLevel ); + + + switch ( LA(1)) { + case ID_self: + { + match(ID_self); + match(SP); + { + switch ( LA(1)) { + case ID_auth: + case ID_compare: + case ID_disclose: + case ID_manage: + case ID_none: + case ID_read: + case ID_search: + case ID_write: + { + who_access_level_level(); + break; + } + case EQUAL: + case PLUS: + case MINUS: + { + who_access_level_priv(); + break; + } + case EOF: + case ID_by: + case SP: + { + break; + } + default: + { + throw new NoViableAltException(LT(1), getFilename()); + } + } + } + + accessLevel.setSelf( true ); + + break; + } + case EOF: + case ID_auth: + case ID_by: + case ID_compare: + case ID_disclose: + case ID_manage: + case ID_none: + case ID_read: + case ID_search: + case ID_write: + case SP: + case EQUAL: + case PLUS: + case MINUS: + { + { + switch ( LA(1)) { + case ID_auth: + case ID_compare: + case ID_disclose: + case ID_manage: + case ID_none: + case ID_read: + case ID_search: + case ID_write: + { + who_access_level_level(); + break; + } + case EQUAL: + case PLUS: + case MINUS: + { + who_access_level_priv(); + break; + } + case EOF: + case ID_by: + case SP: + { + break; + } + default: + { + throw new NoViableAltException(LT(1), getFilename()); + } + } + } + + accessLevel.setSelf( false ); + + break; + } + default: + { + throw new NoViableAltException(LT(1), getFilename()); + } + } + } + + public final void who_control() throws RecognitionException, TokenStreamException { + + + log.debug( "entered who_control()" ); + + List whoClauses = aclItem.getWhoClauses(); + + if ( whoClauses.size() == 0 ) + { + // Throw an exception ? + return; + } + + AclWhoClause whoClause = aclItem.getWhoClauses().get( whoClauses.size() - 1 ); + + + switch ( LA(1)) { + case ID_stop: + { + match(ID_stop); + + whoClause.setControl( AclControlEnum.STOP ); + + break; + } + case ID_continue: + { + match(ID_continue); + + whoClause.setControl( AclControlEnum.CONTINUE ); + + break; + } + case ID_break: + { + match(ID_break); + + whoClause.setControl( AclControlEnum.BREAK ); + + break; + } + default: + { + throw new NoViableAltException(LT(1), getFilename()); + } + } + } + + public final void who_group_type() throws RecognitionException, TokenStreamException { + + + log.debug( "entered who_group_type()" ); + + List whoClauses = aclItem.getWhoClauses(); + AclWhoClause whoClause = aclItem.getWhoClauses().get( whoClauses.size() - 1 ); + + if ( !( whoClause instanceof AclWhoClauseGroup ) ) + { + // Throw an exception ? + return; + } + AclWhoClauseGroup whoClauseGroup = ( AclWhoClauseGroup ) whoClause; + + + switch ( LA(1)) { + case ID_exact: + { + match(ID_exact); + + whoClauseGroup.setType( AclWhoClauseGroupTypeEnum.EXACT ); + + break; + } + case ID_expand: + { + match(ID_expand); + + whoClauseGroup.setType( AclWhoClauseGroupTypeEnum.EXPAND ); + + break; + } + default: + { + throw new NoViableAltException(LT(1), getFilename()); + } + } + } + + public final void who_dn_type() throws RecognitionException, TokenStreamException { + + Token token = null; + + log.debug( "entered who_dn_type()" ); + + List whoClauses = aclItem.getWhoClauses(); + AclWhoClause whoClause = aclItem.getWhoClauses().get( whoClauses.size() - 1 ); + + if ( !( whoClause instanceof AclWhoClauseDn ) ) + { + // Throw an exception ? + return; + } + + AclWhoClauseDn whoClauseDn = ( AclWhoClauseDn ) whoClause; + + + switch ( LA(1)) { + case ID_regex: + { + match(ID_regex); + + whoClauseDn.setType( AclWhoClauseDnTypeEnum.REGEX ); + + break; + } + case ID_base: + { + match(ID_base); + + whoClauseDn.setType( AclWhoClauseDnTypeEnum.BASE ); + + break; + } + case ID_exact: + { + match(ID_exact); + + whoClauseDn.setType( AclWhoClauseDnTypeEnum.EXACT ); + + break; + } + case ID_one: + { + match(ID_one); + + whoClauseDn.setType( AclWhoClauseDnTypeEnum.ONE ); + + break; + } + case ID_subtree: + { + match(ID_subtree); + + whoClauseDn.setType( AclWhoClauseDnTypeEnum.SUBTREE ); + + break; + } + case ID_children: + { + match(ID_children); + + whoClauseDn.setType( AclWhoClauseDnTypeEnum.CHILDREN ); + + break; + } + case ID_level: + { + match(ID_level); + match(OPEN_CURLY); + token = LT(1); + match(INTEGER); + match(CLOSE_CURLY); + + AclWhoClauseDnTypeEnum levelType = AclWhoClauseDnTypeEnum.LEVEL; + levelType.setLevel( Integer.valueOf( token.getText() ) ); + whoClauseDn.setType( levelType ); + + break; + } + default: + { + throw new NoViableAltException(LT(1), getFilename()); + } + } + } + + public final void who_dn_modifier() throws RecognitionException, TokenStreamException { + + + log.debug( "entered who_dn_modifier()" ); + + List whoClauses = aclItem.getWhoClauses(); + AclWhoClause whoClause = aclItem.getWhoClauses().get( whoClauses.size() - 1 ); + + if ( !( whoClause instanceof AclWhoClauseDn ) ) + { + // Throw an exception ? + return; + } + + AclWhoClauseDn whoClauseDn = ( AclWhoClauseDn ) whoClause; + + + match(ID_expand); + + whoClauseDn.setModifier( AclWhoClauseDnModifierEnum.EXPAND ); + + } + + public final void who_access_level_level() throws RecognitionException, TokenStreamException { + + + log.debug( "entered who_access_level_level()" ); + + List whoClauses = aclItem.getWhoClauses(); + + if ( whoClauses.size() == 0 ) + { + // Throw an exception ? + return; + } + + AclWhoClause whoClause = aclItem.getWhoClauses().get( whoClauses.size() - 1 ); + + AclAccessLevel accessLevel = whoClause.getAccessLevel(); + + if ( accessLevel == null ) + { + // Throw an exception ? + return; + } + + + switch ( LA(1)) { + case ID_manage: + { + match(ID_manage); + + accessLevel.setLevel( AclAccessLevelLevelEnum.MANAGE ); + + break; + } + case ID_write: + { + match(ID_write); + + accessLevel.setLevel( AclAccessLevelLevelEnum.WRITE ); + + break; + } + case ID_read: + { + match(ID_read); + + accessLevel.setLevel( AclAccessLevelLevelEnum.READ ); + + break; + } + case ID_search: + { + match(ID_search); + + accessLevel.setLevel( AclAccessLevelLevelEnum.SEARCH ); + + break; + } + case ID_compare: + { + match(ID_compare); + + accessLevel.setLevel( AclAccessLevelLevelEnum.COMPARE ); + + break; + } + case ID_auth: + { + match(ID_auth); + + accessLevel.setLevel( AclAccessLevelLevelEnum.AUTH ); + + break; + } + case ID_disclose: + { + match(ID_disclose); + + accessLevel.setLevel( AclAccessLevelLevelEnum.DISCLOSE ); + + break; + } + case ID_none: + { + match(ID_none); + + accessLevel.setLevel( AclAccessLevelLevelEnum.NONE ); + + break; + } + default: + { + throw new NoViableAltException(LT(1), getFilename()); + } + } + } + + public final void who_access_level_priv() throws RecognitionException, TokenStreamException { + + + log.debug( "entered who_access_level_priv()" ); + + + who_access_level_priv_modifier(); + { + int _cnt135=0; + _loop135: + do { + if ((_tokenSet_3.member(LA(1)))) { + who_access_level_priv_priv(); + } + else { + if ( _cnt135>=1 ) { break _loop135; } else {throw new NoViableAltException(LT(1), getFilename());} + } + + _cnt135++; + } while (true); + } + } + + public final void who_access_level_priv_modifier() throws RecognitionException, TokenStreamException { + + + log.debug( "entered who_access_level_priv_modifier()" ); + + List whoClauses = aclItem.getWhoClauses(); + + if ( whoClauses.size() == 0 ) + { + // Throw an exception ? + return; + } + + AclWhoClause whoClause = aclItem.getWhoClauses().get( whoClauses.size() - 1 ); + + AclAccessLevel accessLevel = whoClause.getAccessLevel(); + + if ( accessLevel == null ) + { + // Throw an exception ? + return; + } + + + switch ( LA(1)) { + case EQUAL: + { + match(EQUAL); + + accessLevel.setPrivilegeModifier( AclAccessLevelPrivModifierEnum.EQUAL ); + + break; + } + case PLUS: + { + match(PLUS); + + accessLevel.setPrivilegeModifier( AclAccessLevelPrivModifierEnum.PLUS ); + + break; + } + case MINUS: + { + match(MINUS); + + accessLevel.setPrivilegeModifier( AclAccessLevelPrivModifierEnum.MINUS ); + + break; + } + default: + { + throw new NoViableAltException(LT(1), getFilename()); + } + } + } + + public final void who_access_level_priv_priv() throws RecognitionException, TokenStreamException { + + + log.debug( "entered who_access_level_priv_priv()" ); + + List whoClauses = aclItem.getWhoClauses(); + + if ( whoClauses.size() == 0 ) + { + // Throw an exception ? + return; + } + + AclWhoClause whoClause = aclItem.getWhoClauses().get( whoClauses.size() - 1 ); + + AclAccessLevel accessLevel = whoClause.getAccessLevel(); + + if ( accessLevel == null ) + { + // Throw an exception ? + return; + } + + + switch ( LA(1)) { + case ID_m: + { + match(ID_m); + + accessLevel.addPrivilege( AclAccessLevelPrivilegeEnum.MANAGE ); + + break; + } + case ID_w: + { + match(ID_w); + + accessLevel.addPrivilege( AclAccessLevelPrivilegeEnum.WRITE ); + + break; + } + case ID_r: + { + match(ID_r); + + accessLevel.addPrivilege( AclAccessLevelPrivilegeEnum.READ ); + + break; + } + case ID_s: + { + match(ID_s); + + accessLevel.addPrivilege( AclAccessLevelPrivilegeEnum.SEARCH ); + + break; + } + case ID_c: + { + match(ID_c); + + accessLevel.addPrivilege( AclAccessLevelPrivilegeEnum.COMPARE ); + + break; + } + case ID_x: + { + match(ID_x); + + accessLevel.addPrivilege( AclAccessLevelPrivilegeEnum.AUTHENTICATION ); + + break; + } + default: + { + throw new NoViableAltException(LT(1), getFilename()); + } + } + } + + + public static final String[] _tokenNames = { + "<0>", + "EOF", + "<2>", + "NULL_TREE_LOOKAHEAD", + "\"access\"", + "\"anonymous\"", + "\"attr\"", + "\"attrs\"", + "\"auth\"", + "\"base\"", + "\"baseobject\"", + "\"break\"", + "\"by\"", + "\"c\"", + "\"children\"", + "\"compare\"", + "\"continue\"", + "\"disclose\"", + "\"dn\"", + "\"dnattr\"", + "\"entry\"", + "\"exact\"", + "\"expand\"", + "\"filter\"", + "\"group\"", + "\"level\"", + "\"m\"", + "\"manage\"", + "\"matchingRule\"", + "\"none\"", + "\"one\"", + "\"onelevel\"", + "\"r\"", + "\"read\"", + "\"regex\"", + "\"s\"", + "\"search\"", + "\"self\"", + "\"stop\"", + "\"sub\"", + "\"subtree\"", + "\"to\"", + "\"users\"", + "\"val\"", + "\"w\"", + "\"x\"", + "\"write\"", + "DIGIT", + "LDIGIT", + "INTEGER", + "DOUBLE_QUOTED_STRING", + "IDENT", + "OPEN_CURLY", + "CLOSE_CURLY", + "SP", + "SSF", + "TRANSPORT_SSF", + "TLS_SSF", + "SASL_SSF", + "DOT", + "SEP", + "EQUAL", + "STAR", + "PLUS", + "MINUS", + "SLASH", + "FILTER", + "FILTER_VALUE", + "STRING", + "REGEX" + }; + + private static final long[] mk_tokenSet_0() { + long[] data = { -6899444044967800574L, 1L, 0L, 0L}; + return data; + } + public static final BitSet _tokenSet_0 = new BitSet(mk_tokenSet_0()); + private static final long[] mk_tokenSet_1() { + long[] data = { 18014673387456514L, 0L}; + return data; + } + public static final BitSet _tokenSet_1 = new BitSet(mk_tokenSet_1()); + private static final long[] mk_tokenSet_2() { + long[] data = { 1652488685056L, 0L}; + return data; + } + public static final BitSet _tokenSet_2 = new BitSet(mk_tokenSet_2()); + private static final long[] mk_tokenSet_3() { + long[] data = { 52815279955968L, 0L}; + return data; + } + public static final BitSet _tokenSet_3 = new BitSet(mk_tokenSet_3()); + + } diff --git a/plugins/openldap.acl.editor/src/main/java/org/apache/directory/studio/openldap/config/acl/model/AntlrAclParser.smap b/plugins/openldap.acl.editor/src/main/java/org/apache/directory/studio/openldap/config/acl/model/AntlrAclParser.smap new file mode 100644 index 0000000000..15f41fa70d --- /dev/null +++ b/plugins/openldap.acl.editor/src/main/java/org/apache/directory/studio/openldap/config/acl/model/AntlrAclParser.smap @@ -0,0 +1,1231 @@ +SMAP +AntlrAclParser.java +G +*S G +*F ++ 0 Acl.g +Acl.g +*L +21:4 +21:6 +21:7 +21:9 +21:10 +21:12 +175:34 +177:36 +179:38 +180:39 +181:40 +182:41 +189:66 +189:103 +190:69 +191:70 +195:74 +195:75 +195:76 +195:78 +195:79 +195:80 +195:81 +195:84 +195:86 +195:87 +195:88 +195:89 +195:96 +195:97 +195:98 +195:99 +195:100 +195:102 +205:105 +205:197 +206:108 +207:109 +209:111 +213:115 +213:116 +213:117 +213:118 +213:119 +213:127 +213:128 +213:129 +213:130 +213:131 +213:134 +213:135 +213:136 +213:137 +213:144 +213:145 +213:146 +213:147 +213:148 +213:150 +213:151 +213:153 +213:154 +213:155 +213:156 +213:157 +213:158 +213:159 +213:160 +213:161 +213:168 +213:169 +213:170 +213:171 +213:172 +213:175 +213:176 +213:177 +213:178 +213:179 +213:180 +213:181 +213:182 +213:183 +213:184 +213:185 +213:187 +213:188 +213:189 +215:191 +216:192 +217:193 +218:194 +219:195 +228:199 +228:236 +229:202 +230:203 +234:207 +234:208 +234:209 +234:210 +234:211 +234:214 +234:215 +234:216 +234:219 +234:220 +234:221 +234:222 +234:225 +234:226 +234:227 +234:230 +234:231 +234:232 +234:233 +234:234 +243:570 +243:581 +244:573 +245:574 +249:577 +251:579 +262:333 +262:344 +262:347 +262:440 +262:441 +262:442 +262:443 +262:445 +263:338 +264:339 +268:342 +268:343 +270:345 +270:346 +272:348 +272:350 +272:351 +272:352 +272:353 +272:360 +272:361 +272:362 +272:363 +272:364 +272:366 +272:368 +272:369 +272:370 +272:371 +272:379 +272:380 +272:381 +272:382 +272:383 +273:386 +273:434 +273:435 +273:436 +273:437 +273:438 +274:387 +274:388 +275:390 +277:335 +277:392 +277:393 +279:395 +280:396 +282:398 +283:399 +284:400 +285:401 +286:402 +287:403 +288:404 +289:405 +291:407 +292:408 +295:336 +295:412 +295:413 +295:414 +295:415 +297:417 +298:418 +300:420 +301:421 +302:422 +303:423 +304:424 +305:425 +306:426 +307:427 +309:429 +310:430 +321:583 +321:592 +321:595 +321:596 +321:597 +321:598 +321:600 +322:586 +323:587 +327:590 +327:591 +327:593 +327:594 +336:680 +336:782 +337:685 +338:686 +339:687 +340:688 +344:691 +346:693 +346:695 +346:696 +346:697 +346:698 +346:705 +346:706 +346:707 +346:708 +346:709 +346:711 +346:713 +346:714 +346:715 +346:716 +346:724 +346:725 +346:726 +346:727 +346:728 +347:731 +347:772 +347:773 +347:774 +347:775 +347:776 +348:682 +348:732 +348:733 +348:734 +348:735 +350:737 +352:739 +353:740 +354:741 +355:742 +356:743 +357:744 +358:745 +359:746 +361:748 +364:683 +364:752 +364:753 +364:754 +364:755 +366:757 +368:759 +369:760 +370:761 +371:762 +372:763 +373:764 +374:765 +375:766 +377:768 +382:780 +392:784 +392:867 +393:789 +394:790 +395:791 +396:792 +400:795 +402:797 +402:799 +402:800 +402:801 +402:802 +402:809 +402:810 +402:811 +402:812 +402:813 +402:815 +402:817 +402:818 +402:819 +402:820 +402:828 +402:829 +402:830 +402:831 +402:832 +404:835 +406:838 +406:857 +406:858 +406:859 +406:860 +406:861 +407:786 +407:839 +407:840 +407:841 +407:842 +409:844 +412:787 +412:848 +412:849 +412:850 +412:851 +414:853 +419:865 +428:602 +428:678 +429:607 +430:608 +431:609 +435:612 +436:614 +436:615 +436:616 +436:617 +436:624 +436:625 +436:626 +436:627 +436:628 +436:630 +436:632 +436:633 +436:634 +436:635 +436:643 +436:644 +436:645 +436:646 +436:647 +437:650 +437:669 +437:670 +437:671 +437:672 +437:673 +438:604 +438:651 +438:652 +438:653 +438:654 +440:656 +443:605 +443:660 +443:661 +443:662 +443:663 +445:665 +449:676 +458:869 +458:870 +458:871 +458:943 +459:874 +460:875 +464:878 +465:880 +465:937 +465:938 +465:939 +465:940 +465:941 +466:881 +466:882 +466:883 +468:885 +471:889 +471:890 +471:891 +473:893 +476:897 +476:898 +476:899 +478:901 +481:905 +481:906 +481:907 +483:909 +486:913 +486:914 +486:915 +488:917 +491:921 +491:922 +491:923 +493:925 +496:929 +496:930 +496:931 +498:933 +506:447 +506:501 +507:451 +508:452 +510:454 +514:449 +514:457 +514:459 +514:460 +514:461 +514:462 +514:469 +514:470 +514:471 +514:472 +514:473 +514:475 +514:477 +514:478 +514:479 +514:480 +514:487 +514:488 +514:489 +514:490 +514:491 +514:493 +514:494 +516:496 +517:497 +519:499 +526:503 +526:568 +527:506 +528:507 +530:509 +534:513 +534:514 +534:515 +534:516 +534:519 +534:520 +534:521 +534:524 +534:525 +534:526 +534:527 +534:528 +534:531 +534:532 +534:533 +534:534 +534:541 +534:542 +534:543 +534:544 +534:545 +534:547 +534:549 +534:550 +534:551 +534:552 +534:561 +534:562 +534:563 +534:564 +534:565 +534:567 +540:945 +540:1011 +541:949 +542:950 +547:955 +547:1005 +547:1006 +547:1007 +547:1008 +547:1009 +548:947 +548:956 +548:957 +548:958 +548:959 +548:961 +548:962 +548:963 +548:965 +548:966 +548:967 +548:969 +548:970 +548:971 +548:972 +548:977 +548:978 +548:979 +548:980 +548:983 +548:984 +548:985 +548:986 +548:987 +550:990 +551:991 +554:995 +554:996 +554:997 +556:1000 +556:1001 +556:1002 +563:1013 +563:1095 +564:1016 +565:1017 +569:1020 +569:1021 +569:1023 +569:1024 +569:1025 +569:1026 +569:1035 +569:1036 +569:1037 +569:1038 +569:1039 +569:1042 +569:1043 +569:1044 +569:1045 +569:1053 +569:1054 +569:1055 +569:1056 +569:1057 +569:1060 +569:1061 +569:1062 +569:1063 +569:1070 +569:1071 +569:1072 +569:1073 +569:1074 +569:1076 +569:1078 +569:1079 +569:1080 +569:1081 +569:1088 +569:1089 +569:1090 +569:1091 +569:1092 +569:1094 +575:1142 +575:1151 +576:1145 +577:1146 +581:1149 +581:1150 +587:1153 +587:1201 +588:1156 +589:1157 +593:1160 +594:1162 +594:1195 +594:1196 +594:1197 +594:1198 +594:1199 +595:1163 +595:1164 +595:1165 +597:1167 +600:1171 +600:1172 +600:1173 +602:1175 +605:1179 +605:1180 +605:1181 +607:1183 +610:1187 +610:1188 +610:1189 +612:1191 +620:1097 +620:1140 +621:1100 +622:1101 +626:1105 +626:1106 +626:1107 +626:1108 +626:1111 +626:1112 +626:1113 +626:1116 +626:1117 +626:1118 +626:1121 +626:1122 +626:1123 +626:1124 +626:1125 +626:1127 +626:1128 +626:1129 +626:1130 +626:1131 +626:1132 +626:1133 +626:1134 +626:1135 +626:1136 +626:1138 +626:1139 +753:238 +753:331 +754:241 +758:245 +758:246 +758:247 +758:248 +758:251 +758:252 +758:253 +758:256 +758:257 +758:258 +758:261 +758:262 +758:263 +758:266 +758:267 +758:268 +758:271 +758:272 +758:273 +758:276 +758:277 +758:278 +758:281 +758:282 +758:283 +758:286 +758:287 +758:288 +758:291 +758:292 +758:293 +758:296 +758:297 +758:298 +758:301 +758:302 +758:303 +758:304 +758:305 +758:308 +758:309 +758:310 +758:311 +758:313 +758:314 +758:315 +758:316 +758:320 +758:321 +758:322 +758:323 +758:325 +758:326 +758:327 +758:328 +761:1215 +761:1225 +762:1218 +766:1221 +768:1223 +771:1227 +771:1237 +772:1230 +776:1233 +778:1235 +781:1239 +781:1249 +782:1242 +786:1245 +788:1247 +791:1203 +791:1213 +792:1206 +796:1209 +798:1211 +801:1342 +801:1393 +802:1346 +804:1348 +805:1349 +809:1344 +809:1352 +809:1354 +809:1355 +809:1356 +809:1357 +809:1364 +809:1365 +809:1366 +809:1367 +809:1368 +809:1370 +809:1372 +809:1373 +809:1374 +809:1375 +809:1382 +809:1383 +809:1384 +809:1385 +809:1386 +809:1388 +809:1389 +811:1391 +814:1395 +814:1485 +815:1401 +817:1403 +818:1404 +822:1397 +822:1398 +822:1399 +822:1407 +822:1409 +822:1410 +822:1411 +822:1412 +822:1413 +822:1414 +822:1416 +822:1417 +822:1418 +822:1419 +822:1420 +822:1421 +822:1429 +822:1430 +822:1431 +822:1432 +822:1433 +822:1442 +822:1443 +822:1444 +822:1445 +822:1446 +822:1449 +822:1450 +822:1451 +822:1452 +822:1453 +822:1460 +822:1461 +822:1462 +822:1463 +822:1464 +822:1466 +822:1467 +822:1468 +824:1470 +825:1471 +826:1472 +827:1473 +829:1475 +830:1476 +831:1477 +832:1478 +834:1480 +835:1481 +836:1482 +837:1483 +840:1724 +840:1740 +840:1757 +840:1758 +840:1759 +840:1760 +840:1761 +840:1762 +841:1727 +843:1729 +844:1730 +846:1732 +847:1733 +848:1734 +849:1735 +850:1736 +851:1737 +855:1741 +855:1742 +855:1743 +857:1745 +860:1749 +860:1750 +860:1751 +862:1753 +866:1251 +866:1340 +867:1255 +869:1257 +870:1258 +874:1253 +874:1261 +874:1263 +874:1264 +874:1265 +874:1266 +874:1267 +874:1269 +874:1270 +874:1271 +874:1272 +874:1273 +874:1281 +874:1282 +874:1283 +874:1284 +874:1285 +874:1294 +874:1295 +874:1296 +874:1297 +874:1298 +874:1301 +874:1302 +874:1303 +874:1304 +874:1311 +874:1312 +874:1313 +874:1314 +874:1315 +874:1317 +874:1319 +874:1320 +874:1321 +874:1322 +874:1329 +874:1330 +874:1331 +874:1332 +874:1333 +874:1335 +874:1336 +876:1338 +879:1764 +879:1782 +879:1845 +879:1846 +879:1847 +879:1848 +879:1849 +879:1850 +880:1768 +882:1770 +883:1771 +885:1773 +886:1774 +887:1775 +888:1776 +889:1777 +891:1779 +895:1783 +895:1784 +895:1785 +897:1787 +900:1791 +900:1792 +900:1793 +902:1795 +905:1799 +905:1800 +905:1801 +907:1803 +910:1807 +910:1808 +910:1809 +912:1811 +915:1815 +915:1816 +915:1817 +917:1819 +920:1823 +920:1824 +920:1825 +922:1827 +925:1766 +925:1831 +925:1832 +925:1833 +925:1834 +925:1835 +925:1836 +925:1837 +927:1839 +928:1840 +929:1841 +933:1852 +933:1873 +934:1855 +936:1857 +937:1858 +939:1860 +940:1861 +941:1862 +942:1863 +943:1864 +945:1866 +949:1869 +951:1871 +955:1555 +955:1573 +955:1669 +955:1670 +955:1671 +955:1672 +955:1673 +955:1674 +956:1558 +958:1560 +960:1562 +961:1563 +962:1564 +963:1565 +964:1566 +966:1568 +967:1569 +968:1570 +972:1574 +972:1575 +972:1576 +972:1577 +972:1579 +972:1580 +972:1581 +972:1582 +972:1583 +972:1584 +972:1585 +972:1586 +972:1587 +972:1588 +972:1589 +972:1592 +972:1593 +972:1594 +972:1595 +972:1596 +972:1605 +972:1606 +972:1607 +972:1608 +972:1609 +974:1612 +977:1616 +977:1617 +977:1618 +977:1619 +977:1620 +977:1621 +977:1622 +977:1623 +977:1624 +977:1625 +977:1626 +977:1627 +977:1628 +977:1629 +977:1630 +977:1632 +977:1633 +977:1634 +977:1635 +977:1636 +977:1637 +977:1638 +977:1639 +977:1640 +977:1641 +977:1642 +977:1645 +977:1646 +977:1647 +977:1648 +977:1649 +977:1658 +977:1659 +977:1660 +977:1661 +977:1662 +979:1665 +983:1875 +983:1899 +983:1964 +983:1965 +983:1966 +983:1967 +983:1968 +983:1969 +984:1878 +986:1880 +988:1882 +989:1883 +990:1884 +991:1885 +992:1886 +994:1888 +996:1890 +998:1892 +999:1893 +1000:1894 +1001:1895 +1002:1896 +1006:1900 +1006:1901 +1006:1902 +1008:1904 +1011:1908 +1011:1909 +1011:1910 +1013:1912 +1016:1916 +1016:1917 +1016:1918 +1018:1920 +1021:1924 +1021:1925 +1021:1926 +1023:1928 +1026:1932 +1026:1933 +1026:1934 +1028:1936 +1031:1940 +1031:1941 +1031:1942 +1033:1944 +1036:1948 +1036:1949 +1036:1950 +1038:1952 +1041:1956 +1041:1957 +1041:1958 +1043:1960 +1047:1971 +1047:1992 +1048:1974 +1052:1977 +1052:1979 +1052:1980 +1052:1981 +1052:1982 +1052:1983 +1052:1984 +1052:1985 +1052:1986 +1052:1987 +1052:1989 +1052:1990 +1052:1991 +1055:1994 +1055:2018 +1055:2043 +1055:2044 +1055:2045 +1055:2046 +1055:2047 +1055:2048 +1056:1997 +1058:1999 +1060:2001 +1061:2002 +1062:2003 +1063:2004 +1064:2005 +1066:2007 +1068:2009 +1070:2011 +1071:2012 +1072:2013 +1073:2014 +1074:2015 +1078:2019 +1078:2020 +1078:2021 +1080:2023 +1083:2027 +1083:2028 +1083:2029 +1085:2031 +1088:2035 +1088:2036 +1088:2037 +1090:2039 +1094:2050 +1094:2074 +1094:2123 +1094:2124 +1094:2125 +1094:2126 +1094:2127 +1094:2128 +1095:2053 +1097:2055 +1099:2057 +1100:2058 +1101:2059 +1102:2060 +1103:2061 +1105:2063 +1107:2065 +1109:2067 +1110:2068 +1111:2069 +1112:2070 +1113:2071 +1117:2075 +1117:2076 +1117:2077 +1119:2079 +1122:2083 +1122:2084 +1122:2085 +1124:2087 +1127:2091 +1127:2092 +1127:2093 +1129:2095 +1132:2099 +1132:2100 +1132:2101 +1134:2103 +1137:2107 +1137:2108 +1137:2109 +1139:2111 +1142:2115 +1142:2116 +1142:2117 +1144:2119 +1148:1676 +1148:1692 +1148:1717 +1148:1718 +1148:1719 +1148:1720 +1148:1721 +1148:1722 +1149:1679 +1151:1681 +1153:1683 +1154:1684 +1155:1685 +1156:1686 +1157:1687 +1159:1689 +1163:1693 +1163:1694 +1163:1695 +1165:1697 +1168:1701 +1168:1702 +1168:1703 +1170:1705 +1173:1709 +1173:1710 +1173:1711 +1175:1713 +1179:1487 +1179:1502 +1180:1491 +1182:1493 +1183:1494 +1187:1489 +1187:1497 +1187:1498 +1189:1500 +1193:1504 +1193:1519 +1194:1508 +1196:1510 +1197:1511 +1201:1506 +1201:1514 +1201:1515 +1203:1517 +1207:1521 +1207:1536 +1208:1525 +1210:1527 +1211:1528 +1215:1523 +1215:1531 +1215:1532 +1217:1534 +1221:1538 +1221:1553 +1222:1542 +1224:1544 +1225:1545 +1229:1540 +1229:1548 +1229:1549 +1231:1551 +*E