Source code

001// $ANTLR 2.7.7 (20060906): "schema-value.g" -> "AntlrSchemaValueLexer.java"$
002
003/*
004 *  Licensed to the Apache Software Foundation (ASF) under one
005 *  or more contributor license agreements.  See the NOTICE file
006 *  distributed with this work for additional information
007 *  regarding copyright ownership.  The ASF licenses this file
008 *  to you under the Apache License, Version 2.0 (the
009 *  "License"); you may not use this file except in compliance
010 *  with the License.  You may obtain a copy of the License at
011 *  
012 *    http://www.apache.org/licenses/LICENSE-2.0
013 *  
014 *  Unless required by applicable law or agreed to in writing,
015 *  software distributed under the License is distributed on an
016 *  "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
017 *  KIND, either express or implied.  See the License for the
018 *  specific language governing permissions and limitations
019 *  under the License. 
020 *  
021 */
022package org.apache.directory.shared.ldap.model.schema.syntaxes;
023
024import java.util.List;
025import java.util.ArrayList;
026
027import org.apache.directory.shared.ldap.model.schema.parsers.ParserMonitor;
028
029
030import java.io.InputStream;
031import antlr.TokenStreamException;
032import antlr.TokenStreamIOException;
033import antlr.TokenStreamRecognitionException;
034import antlr.CharStreamException;
035import antlr.CharStreamIOException;
036import antlr.ANTLRException;
037import java.io.Reader;
038import java.util.Hashtable;
039import antlr.CharScanner;
040import antlr.InputBuffer;
041import antlr.ByteBuffer;
042import antlr.CharBuffer;
043import antlr.Token;
044import antlr.CommonToken;
045import antlr.RecognitionException;
046import antlr.NoViableAltForCharException;
047import antlr.MismatchedCharException;
048import antlr.TokenStream;
049import antlr.ANTLRHashString;
050import antlr.LexerSharedInputState;
051import antlr.collections.impl.BitSet;
052import antlr.SemanticException;
053
054/**
055 * An antlr generated schema lexer. This is a sub-lexer.
056 *
057 * @author <a href="mailto:dev@directory.apache.org">Apache Directory Project</a>
058 */
059public class AntlrSchemaValueLexer extends antlr.CharScanner implements AntlrSchemaValueTokenTypes, TokenStream
060 {
061public AntlrSchemaValueLexer(InputStream in) {
062        this(new ByteBuffer(in));
063}
064public AntlrSchemaValueLexer(Reader in) {
065        this(new CharBuffer(in));
066}
067public AntlrSchemaValueLexer(InputBuffer ib) {
068        this(new LexerSharedInputState(ib));
069}
070public AntlrSchemaValueLexer(LexerSharedInputState state) {
071        super(state);
072        caseSensitiveLiterals = true;
073        setCaseSensitive(false);
074        literals = new Hashtable();
075}
076
077public Token nextToken() throws TokenStreamException {
078        Token theRetToken=null;
079tryAgain:
080        for (;;) {
081                Token _token = null;
082                int _ttype = Token.INVALID_TYPE;
083                resetText();
084                try {   // for char stream error handling
085                        try {   // for lexical error handling
086                                switch ( LA(1)) {
087                                case '\t':  case '\n':  case '\r':  case ' ':
088                                case '#':
089                                {
090                                        mWHSP(true);
091                                        theRetToken=_returnToken;
092                                        break;
093                                }
094                                case '(':
095                                {
096                                        mLPAR(true);
097                                        theRetToken=_returnToken;
098                                        break;
099                                }
100                                case ')':
101                                {
102                                        mRPAR(true);
103                                        theRetToken=_returnToken;
104                                        break;
105                                }
106                                case '\'':
107                                {
108                                        mQUOTE(true);
109                                        theRetToken=_returnToken;
110                                        break;
111                                }
112                                case '$':
113                                {
114                                        mDOLLAR(true);
115                                        theRetToken=_returnToken;
116                                        break;
117                                }
118                                case '}':
119                                {
120                                        mRCURLY(true);
121                                        theRetToken=_returnToken;
122                                        break;
123                                }
124                                case '-':  case '.':  case '0':  case '1':
125                                case '2':  case '3':  case '4':  case '5':
126                                case '6':  case '7':  case '8':  case '9':
127                                case ':':  case ';':  case '_':  case 'a':
128                                case 'b':  case 'c':  case 'd':  case 'e':
129                                case 'f':  case 'g':  case 'h':  case 'i':
130                                case 'j':  case 'k':  case 'l':  case 'm':
131                                case 'n':  case 'o':  case 'p':  case 'q':
132                                case 'r':  case 's':  case 't':  case 'u':
133                                case 'v':  case 'w':  case 'x':  case 'y':
134                                case 'z':
135                                {
136                                        mDESCR_OR_QUIRKS_DESCR(true);
137                                        theRetToken=_returnToken;
138                                        break;
139                                }
140                                default:
141                                        if ((LA(1)=='{') && ((LA(2) >= '0' && LA(2) <= '9'))) {
142                                                mLEN(true);
143                                                theRetToken=_returnToken;
144                                        }
145                                        else if ((LA(1)=='{') && (true)) {
146                                                mLCURLY(true);
147                                                theRetToken=_returnToken;
148                                        }
149                                else {
150                                        if (LA(1)==EOF_CHAR) {uponEOF(); _returnToken = makeToken(Token.EOF_TYPE);}
151                                else {throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());}
152                                }
153                                }
154                                if ( _returnToken==null ) continue tryAgain; // found SKIP token
155                                _ttype = _returnToken.getType();
156                                _ttype = testLiteralsTable(_ttype);
157                                _returnToken.setType(_ttype);
158                                return _returnToken;
159                        }
160                        catch (RecognitionException e) {
161                                throw new TokenStreamRecognitionException(e);
162                        }
163                }
164                catch (CharStreamException cse) {
165                        if ( cse instanceof CharStreamIOException ) {
166                                throw new TokenStreamIOException(((CharStreamIOException)cse).io);
167                        }
168                        else {
169                                throw new TokenStreamException(cse.getMessage());
170                        }
171                }
172        }
173}
174
175        public final void mWHSP(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
176                int _ttype; Token _token=null; int _begin=text.length();
177                _ttype = WHSP;
178                int _saveIndex;
179                
180                {
181                int _cnt6=0;
182                _loop6:
183                do {
184                        switch ( LA(1)) {
185                        case ' ':
186                        {
187                                match(' ');
188                                break;
189                        }
190                        case '\t':
191                        {
192                                match('\t');
193                                break;
194                        }
195                        case '\r':
196                        {
197                                match('\r');
198                                {
199                                if ((LA(1)=='\n') && (true) && (true)) {
200                                        match('\n');
201                                }
202                                else {
203                                }
204                                
205                                }
206                                if ( inputState.guessing==0 ) {
207                                        newline();
208                                }
209                                break;
210                        }
211                        case '\n':
212                        {
213                                match('\n');
214                                if ( inputState.guessing==0 ) {
215                                        newline();
216                                }
217                                break;
218                        }
219                        case '#':
220                        {
221                                match('#');
222                                {
223                                _loop5:
224                                do {
225                                        if ((_tokenSet_0.member(LA(1)))) {
226                                                matchNot('\n');
227                                        }
228                                        else {
229                                                break _loop5;
230                                        }
231                                        
232                                } while (true);
233                                }
234                                match('\n');
235                                if ( inputState.guessing==0 ) {
236                                        newline();
237                                }
238                                break;
239                        }
240                        default:
241                        {
242                                if ( _cnt6>=1 ) { break _loop6; } else {throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());}
243                        }
244                        }
245                        _cnt6++;
246                } while (true);
247                }
248                if ( inputState.guessing==0 ) {
249                        setText(" ");
250                }
251                if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
252                        _token = makeToken(_ttype);
253                        _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
254                }
255                _returnToken = _token;
256        }
257        
258        public final void mLPAR(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
259                int _ttype; Token _token=null; int _begin=text.length();
260                _ttype = LPAR;
261                int _saveIndex;
262                
263                match('(');
264                if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
265                        _token = makeToken(_ttype);
266                        _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
267                }
268                _returnToken = _token;
269        }
270        
271        public final void mRPAR(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
272                int _ttype; Token _token=null; int _begin=text.length();
273                _ttype = RPAR;
274                int _saveIndex;
275                
276                match(')');
277                if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
278                        _token = makeToken(_ttype);
279                        _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
280                }
281                _returnToken = _token;
282        }
283        
284        protected final void mCHAR(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
285                int _ttype; Token _token=null; int _begin=text.length();
286                _ttype = CHAR;
287                int _saveIndex;
288                
289                matchRange('a','z');
290                if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
291                        _token = makeToken(_ttype);
292                        _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
293                }
294                _returnToken = _token;
295        }
296        
297        protected final void mLDIGIT(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
298                int _ttype; Token _token=null; int _begin=text.length();
299                _ttype = LDIGIT;
300                int _saveIndex;
301                
302                matchRange('1','9');
303                if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
304                        _token = makeToken(_ttype);
305                        _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
306                }
307                _returnToken = _token;
308        }
309        
310        protected final void mDIGIT(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
311                int _ttype; Token _token=null; int _begin=text.length();
312                _ttype = DIGIT;
313                int _saveIndex;
314                
315                matchRange('0','9');
316                if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
317                        _token = makeToken(_ttype);
318                        _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
319                }
320                _returnToken = _token;
321        }
322        
323        protected final void mNUMBER(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
324                int _ttype; Token _token=null; int _begin=text.length();
325                _ttype = NUMBER;
326                int _saveIndex;
327                
328                if (((LA(1) >= '1' && LA(1) <= '9')) && ((LA(2) >= '0' && LA(2) <= '9'))) {
329                        {
330                        mLDIGIT(false);
331                        {
332                        int _cnt15=0;
333                        _loop15:
334                        do {
335                                if (((LA(1) >= '0' && LA(1) <= '9'))) {
336                                        mDIGIT(false);
337                                }
338                                else {
339                                        if ( _cnt15>=1 ) { break _loop15; } else {throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());}
340                                }
341                                
342                                _cnt15++;
343                        } while (true);
344                        }
345                        }
346                }
347                else if (((LA(1) >= '0' && LA(1) <= '9')) && (true)) {
348                        mDIGIT(false);
349                }
350                else {
351                        throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
352                }
353                
354                if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
355                        _token = makeToken(_ttype);
356                        _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
357                }
358                _returnToken = _token;
359        }
360        
361        protected final void mNUMBER2(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
362                int _ttype; Token _token=null; int _begin=text.length();
363                _ttype = NUMBER2;
364                int _saveIndex;
365                
366                {
367                int _cnt18=0;
368                _loop18:
369                do {
370                        if (((LA(1) >= '0' && LA(1) <= '9'))) {
371                                mDIGIT(false);
372                        }
373                        else {
374                                if ( _cnt18>=1 ) { break _loop18; } else {throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());}
375                        }
376                        
377                        _cnt18++;
378                } while (true);
379                }
380                if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
381                        _token = makeToken(_ttype);
382                        _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
383                }
384                _returnToken = _token;
385        }
386        
387        protected final void mNUMERICOID(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
388                int _ttype; Token _token=null; int _begin=text.length();
389                _ttype = NUMERICOID;
390                int _saveIndex;
391                
392                mNUMBER(false);
393                {
394                int _cnt21=0;
395                _loop21:
396                do {
397                        if ((LA(1)=='.')) {
398                                match('.');
399                                mNUMBER(false);
400                        }
401                        else {
402                                if ( _cnt21>=1 ) { break _loop21; } else {throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());}
403                        }
404                        
405                        _cnt21++;
406                } while (true);
407                }
408                if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
409                        _token = makeToken(_ttype);
410                        _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
411                }
412                _returnToken = _token;
413        }
414        
415        protected final void mHYPEN(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
416                int _ttype; Token _token=null; int _begin=text.length();
417                _ttype = HYPEN;
418                int _saveIndex;
419                
420                match('-');
421                if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
422                        _token = makeToken(_ttype);
423                        _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
424                }
425                _returnToken = _token;
426        }
427        
428        protected final void mOTHER(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
429                int _ttype; Token _token=null; int _begin=text.length();
430                _ttype = OTHER;
431                int _saveIndex;
432                
433                switch ( LA(1)) {
434                case '_':
435                {
436                        match('_');
437                        break;
438                }
439                case ';':
440                {
441                        match(';');
442                        break;
443                }
444                case '.':
445                {
446                        match('.');
447                        break;
448                }
449                case ':':
450                {
451                        match(':');
452                        break;
453                }
454                default:
455                {
456                        throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
457                }
458                }
459                if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
460                        _token = makeToken(_ttype);
461                        _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
462                }
463                _returnToken = _token;
464        }
465        
466        protected final void mDESCR(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
467                int _ttype; Token _token=null; int _begin=text.length();
468                _ttype = DESCR;
469                int _saveIndex;
470                
471                mCHAR(false);
472                {
473                _loop26:
474                do {
475                        switch ( LA(1)) {
476                        case 'a':  case 'b':  case 'c':  case 'd':
477                        case 'e':  case 'f':  case 'g':  case 'h':
478                        case 'i':  case 'j':  case 'k':  case 'l':
479                        case 'm':  case 'n':  case 'o':  case 'p':
480                        case 'q':  case 'r':  case 's':  case 't':
481                        case 'u':  case 'v':  case 'w':  case 'x':
482                        case 'y':  case 'z':
483                        {
484                                mCHAR(false);
485                                break;
486                        }
487                        case '0':  case '1':  case '2':  case '3':
488                        case '4':  case '5':  case '6':  case '7':
489                        case '8':  case '9':
490                        {
491                                mDIGIT(false);
492                                break;
493                        }
494                        case '-':
495                        {
496                                mHYPEN(false);
497                                break;
498                        }
499                        default:
500                        {
501                                break _loop26;
502                        }
503                        }
504                } while (true);
505                }
506                if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
507                        _token = makeToken(_ttype);
508                        _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
509                }
510                _returnToken = _token;
511        }
512        
513        protected final void mQUIRKS_DESCR(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
514                int _ttype; Token _token=null; int _begin=text.length();
515                _ttype = QUIRKS_DESCR;
516                int _saveIndex;
517                
518                {
519                int _cnt29=0;
520                _loop29:
521                do {
522                        switch ( LA(1)) {
523                        case 'a':  case 'b':  case 'c':  case 'd':
524                        case 'e':  case 'f':  case 'g':  case 'h':
525                        case 'i':  case 'j':  case 'k':  case 'l':
526                        case 'm':  case 'n':  case 'o':  case 'p':
527                        case 'q':  case 'r':  case 's':  case 't':
528                        case 'u':  case 'v':  case 'w':  case 'x':
529                        case 'y':  case 'z':
530                        {
531                                mCHAR(false);
532                                break;
533                        }
534                        case '0':  case '1':  case '2':  case '3':
535                        case '4':  case '5':  case '6':  case '7':
536                        case '8':  case '9':
537                        {
538                                mDIGIT(false);
539                                break;
540                        }
541                        case '-':
542                        {
543                                mHYPEN(false);
544                                break;
545                        }
546                        case '.':  case ':':  case ';':  case '_':
547                        {
548                                mOTHER(false);
549                                break;
550                        }
551                        default:
552                        {
553                                if ( _cnt29>=1 ) { break _loop29; } else {throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());}
554                        }
555                        }
556                        _cnt29++;
557                } while (true);
558                }
559                if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
560                        _token = makeToken(_ttype);
561                        _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
562                }
563                _returnToken = _token;
564        }
565        
566        public final void mQUOTE(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
567                int _ttype; Token _token=null; int _begin=text.length();
568                _ttype = QUOTE;
569                int _saveIndex;
570                
571                match('\'');
572                if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
573                        _token = makeToken(_ttype);
574                        _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
575                }
576                _returnToken = _token;
577        }
578        
579        public final void mDOLLAR(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
580                int _ttype; Token _token=null; int _begin=text.length();
581                _ttype = DOLLAR;
582                int _saveIndex;
583                
584                match('$');
585                if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
586                        _token = makeToken(_ttype);
587                        _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
588                }
589                _returnToken = _token;
590        }
591        
592        public final void mLCURLY(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
593                int _ttype; Token _token=null; int _begin=text.length();
594                _ttype = LCURLY;
595                int _saveIndex;
596                
597                match('{');
598                if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
599                        _token = makeToken(_ttype);
600                        _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
601                }
602                _returnToken = _token;
603        }
604        
605        public final void mRCURLY(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
606                int _ttype; Token _token=null; int _begin=text.length();
607                _ttype = RCURLY;
608                int _saveIndex;
609                
610                match('}');
611                if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
612                        _token = makeToken(_ttype);
613                        _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
614                }
615                _returnToken = _token;
616        }
617        
618        public final void mLEN(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
619                int _ttype; Token _token=null; int _begin=text.length();
620                _ttype = LEN;
621                int _saveIndex;
622                Token n=null;
623                
624                mLCURLY(false);
625                mNUMBER2(true);
626                n=_returnToken;
627                mRCURLY(false);
628                if ( inputState.guessing==0 ) {
629                        setText(n.getText());
630                }
631                if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
632                        _token = makeToken(_ttype);
633                        _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
634                }
635                _returnToken = _token;
636        }
637        
638        public final void mDESCR_OR_QUIRKS_DESCR(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
639                int _ttype; Token _token=null; int _begin=text.length();
640                _ttype = DESCR_OR_QUIRKS_DESCR;
641                int _saveIndex;
642                
643                boolean synPredMatched48 = false;
644                if ((((LA(1) >= '0' && LA(1) <= '9')) && (_tokenSet_1.member(LA(2))) && (_tokenSet_1.member(LA(3))))) {
645                        int _m48 = mark();
646                        synPredMatched48 = true;
647                        inputState.guessing++;
648                        try {
649                                {
650                                mNUMBER(false);
651                                match('.');
652                                }
653                        }
654                        catch (RecognitionException pe) {
655                                synPredMatched48 = false;
656                        }
657                        rewind(_m48);
658inputState.guessing--;
659                }
660                if ( synPredMatched48 ) {
661                        mNUMERICOID(false);
662                        if ( inputState.guessing==0 ) {
663                                _ttype =  NUMERICOID;
664                        }
665                }
666                else {
667                        boolean synPredMatched37 = false;
668                        if (((_tokenSet_2.member(LA(1))) && (true) && (true))) {
669                                int _m37 = mark();
670                                synPredMatched37 = true;
671                                inputState.guessing++;
672                                try {
673                                        {
674                                        mNUMERICOID(false);
675                                        mQUIRKS_DESCR(false);
676                                        }
677                                }
678                                catch (RecognitionException pe) {
679                                        synPredMatched37 = false;
680                                }
681                                rewind(_m37);
682inputState.guessing--;
683                        }
684                        if ( synPredMatched37 ) {
685                                mQUIRKS_DESCR(false);
686                                if ( inputState.guessing==0 ) {
687                                        _ttype =  QUIRKS_DESCR;
688                                }
689                        }
690                        else {
691                                boolean synPredMatched39 = false;
692                                if (((_tokenSet_2.member(LA(1))) && (true) && (true))) {
693                                        int _m39 = mark();
694                                        synPredMatched39 = true;
695                                        inputState.guessing++;
696                                        try {
697                                                {
698                                                mNUMBER(false);
699                                                mQUIRKS_DESCR(false);
700                                                }
701                                        }
702                                        catch (RecognitionException pe) {
703                                                synPredMatched39 = false;
704                                        }
705                                        rewind(_m39);
706inputState.guessing--;
707                                }
708                                if ( synPredMatched39 ) {
709                                        mQUIRKS_DESCR(false);
710                                        if ( inputState.guessing==0 ) {
711                                                _ttype =  QUIRKS_DESCR;
712                                        }
713                                }
714                                else {
715                                        boolean synPredMatched41 = false;
716                                        if (((_tokenSet_2.member(LA(1))) && (true) && (true))) {
717                                                int _m41 = mark();
718                                                synPredMatched41 = true;
719                                                inputState.guessing++;
720                                                try {
721                                                        {
722                                                        mHYPEN(false);
723                                                        mQUIRKS_DESCR(false);
724                                                        }
725                                                }
726                                                catch (RecognitionException pe) {
727                                                        synPredMatched41 = false;
728                                                }
729                                                rewind(_m41);
730inputState.guessing--;
731                                        }
732                                        if ( synPredMatched41 ) {
733                                                mQUIRKS_DESCR(false);
734                                                if ( inputState.guessing==0 ) {
735                                                        _ttype =  QUIRKS_DESCR;
736                                                }
737                                        }
738                                        else {
739                                                boolean synPredMatched43 = false;
740                                                if (((_tokenSet_2.member(LA(1))) && (true) && (true))) {
741                                                        int _m43 = mark();
742                                                        synPredMatched43 = true;
743                                                        inputState.guessing++;
744                                                        try {
745                                                                {
746                                                                mOTHER(false);
747                                                                mQUIRKS_DESCR(false);
748                                                                }
749                                                        }
750                                                        catch (RecognitionException pe) {
751                                                                synPredMatched43 = false;
752                                                        }
753                                                        rewind(_m43);
754inputState.guessing--;
755                                                }
756                                                if ( synPredMatched43 ) {
757                                                        mQUIRKS_DESCR(false);
758                                                        if ( inputState.guessing==0 ) {
759                                                                _ttype =  QUIRKS_DESCR;
760                                                        }
761                                                }
762                                                else {
763                                                        boolean synPredMatched45 = false;
764                                                        if (((_tokenSet_2.member(LA(1))) && (true) && (true))) {
765                                                                int _m45 = mark();
766                                                                synPredMatched45 = true;
767                                                                inputState.guessing++;
768                                                                try {
769                                                                        {
770                                                                        mDESCR(false);
771                                                                        mQUIRKS_DESCR(false);
772                                                                        }
773                                                                }
774                                                                catch (RecognitionException pe) {
775                                                                        synPredMatched45 = false;
776                                                                }
777                                                                rewind(_m45);
778inputState.guessing--;
779                                                        }
780                                                        if ( synPredMatched45 ) {
781                                                                mQUIRKS_DESCR(false);
782                                                                if ( inputState.guessing==0 ) {
783                                                                        _ttype =  QUIRKS_DESCR;
784                                                                }
785                                                        }
786                                                        else if (((LA(1) >= 'a' && LA(1) <= 'z')) && (true) && (true)) {
787                                                                {
788                                                                mDESCR(false);
789                                                                }
790                                                                if ( inputState.guessing==0 ) {
791                                                                        _ttype =  DESCR;
792                                                                }
793                                                        }
794                                                        else if (((LA(1) >= '0' && LA(1) <= '9')) && (true) && (true)) {
795                                                                {
796                                                                mNUMBER(false);
797                                                                }
798                                                                if ( inputState.guessing==0 ) {
799                                                                        _ttype =  NUMBER;
800                                                                }
801                                                        }
802                                                        else {
803                                                                throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
804                                                        }
805                                                        }}}}}
806                                                        if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
807                                                                _token = makeToken(_ttype);
808                                                                _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
809                                                        }
810                                                        _returnToken = _token;
811                                                }
812                                                
813                                                
814                                                private static final long[] mk_tokenSet_0() {
815                                                        long[] data = new long[8];
816                                                        data[0]=-1032L;
817                                                        for (int i = 1; i<=3; i++) { data[i]=-1L; }
818                                                        return data;
819                                                }
820                                                public static final BitSet _tokenSet_0 = new BitSet(mk_tokenSet_0());
821                                                private static final long[] mk_tokenSet_1() {
822                                                        long[] data = { 288019269919178752L, 0L, 0L, 0L, 0L};
823                                                        return data;
824                                                }
825                                                public static final BitSet _tokenSet_1 = new BitSet(mk_tokenSet_1());
826                                                private static final long[] mk_tokenSet_2() {
827                                                        long[] data = { 1152745582746402816L, 576460745860972544L, 0L, 0L, 0L};
828                                                        return data;
829                                                }
830                                                public static final BitSet _tokenSet_2 = new BitSet(mk_tokenSet_2());
831                                                
832                                                }