Source code

001// $ANTLR 2.7.7 (20060906): "schema-value.g" -> "AntlrSchemaValueParser.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 antlr.TokenBuffer;
031import antlr.TokenStreamException;
032import antlr.TokenStreamIOException;
033import antlr.ANTLRException;
034import antlr.LLkParser;
035import antlr.Token;
036import antlr.TokenStream;
037import antlr.RecognitionException;
038import antlr.NoViableAltException;
039import antlr.MismatchedTokenException;
040import antlr.SemanticException;
041import antlr.ParserSharedInputState;
042import antlr.collections.impl.BitSet;
043
044/**
045 * An antlr generated schema parser. This is a sub-parser used to parse
046 * numericoid, oid, oids, qdescr, qdescrs according to RFC4512.
047 *
048 * @author <a href="mailto:dev@directory.apache.org">Apache Directory Project</a>
049 */
050public class AntlrSchemaValueParser extends antlr.LLkParser       implements AntlrSchemaValueTokenTypes
051 {
052
053    private ParserMonitor monitor = null;
054    public void setParserMonitor( ParserMonitor monitor )
055    {
056        this.monitor = monitor;
057    }
058    private void matchedProduction( String msg )
059    {
060        if ( null != monitor )
061        {
062            monitor.matchedProduction( msg );
063        }
064    }
065
066protected AntlrSchemaValueParser(TokenBuffer tokenBuf, int k) {
067  super(tokenBuf,k);
068  tokenNames = _tokenNames;
069}
070
071public AntlrSchemaValueParser(TokenBuffer tokenBuf) {
072  this(tokenBuf,3);
073}
074
075protected AntlrSchemaValueParser(TokenStream lexer, int k) {
076  super(lexer,k);
077  tokenNames = _tokenNames;
078}
079
080public AntlrSchemaValueParser(TokenStream lexer) {
081  this(lexer,3);
082}
083
084public AntlrSchemaValueParser(ParserSharedInputState state) {
085  super(state,3);
086  tokenNames = _tokenNames;
087}
088
089/**
090     * noidlen = numericoid [ LCURLY len RCURLY ]
091     * len = number
092     */
093        public final AntlrSchemaParser.NoidLen  noidlen() throws RecognitionException, TokenStreamException {
094                AntlrSchemaParser.NoidLen noidlen = new AntlrSchemaParser.NoidLen();
095                
096                Token  d4 = null;
097                Token  n2 = null;
098                Token  l = null;
099                
100                matchedProduction( "AntlrSchemaValueParser.noidlen()" );
101                
102                
103                {
104                {
105                switch ( LA(1)) {
106                case LPAR:
107                {
108                        match(LPAR);
109                        break;
110                }
111                case WHSP:
112                case NUMERICOID:
113                case DESCR:
114                case QUOTE:
115                {
116                        break;
117                }
118                default:
119                {
120                        throw new NoViableAltException(LT(1), getFilename());
121                }
122                }
123                }
124                {
125                switch ( LA(1)) {
126                case WHSP:
127                {
128                        match(WHSP);
129                        break;
130                }
131                case NUMERICOID:
132                case DESCR:
133                case QUOTE:
134                {
135                        break;
136                }
137                default:
138                {
139                        throw new NoViableAltException(LT(1), getFilename());
140                }
141                }
142                }
143                {
144                switch ( LA(1)) {
145                case QUOTE:
146                {
147                        match(QUOTE);
148                        break;
149                }
150                case NUMERICOID:
151                case DESCR:
152                {
153                        break;
154                }
155                default:
156                {
157                        throw new NoViableAltException(LT(1), getFilename());
158                }
159                }
160                }
161                {
162                switch ( LA(1)) {
163                case DESCR:
164                {
165                        {
166                        d4 = LT(1);
167                        match(DESCR);
168                        noidlen.noid = d4.getText();
169                        }
170                        break;
171                }
172                case NUMERICOID:
173                {
174                        {
175                        n2 = LT(1);
176                        match(NUMERICOID);
177                        noidlen.noid = n2.getText();
178                        }
179                        break;
180                }
181                default:
182                {
183                        throw new NoViableAltException(LT(1), getFilename());
184                }
185                }
186                }
187                {
188                switch ( LA(1)) {
189                case QUOTE:
190                {
191                        match(QUOTE);
192                        break;
193                }
194                case EOF:
195                case WHSP:
196                case RPAR:
197                case LEN:
198                {
199                        break;
200                }
201                default:
202                {
203                        throw new NoViableAltException(LT(1), getFilename());
204                }
205                }
206                }
207                {
208                switch ( LA(1)) {
209                case WHSP:
210                {
211                        match(WHSP);
212                        break;
213                }
214                case EOF:
215                case RPAR:
216                case LEN:
217                {
218                        break;
219                }
220                default:
221                {
222                        throw new NoViableAltException(LT(1), getFilename());
223                }
224                }
225                }
226                {
227                switch ( LA(1)) {
228                case RPAR:
229                {
230                        match(RPAR);
231                        break;
232                }
233                case EOF:
234                case LEN:
235                {
236                        break;
237                }
238                default:
239                {
240                        throw new NoViableAltException(LT(1), getFilename());
241                }
242                }
243                }
244                {
245                switch ( LA(1)) {
246                case LEN:
247                {
248                        l = LT(1);
249                        match(LEN);
250                        noidlen.len = Long.parseLong(l.getText());
251                        {
252                        switch ( LA(1)) {
253                        case QUOTE:
254                        {
255                                match(QUOTE);
256                                break;
257                        }
258                        case EOF:
259                        case WHSP:
260                        case RPAR:
261                        {
262                                break;
263                        }
264                        default:
265                        {
266                                throw new NoViableAltException(LT(1), getFilename());
267                        }
268                        }
269                        }
270                        {
271                        switch ( LA(1)) {
272                        case WHSP:
273                        {
274                                match(WHSP);
275                                break;
276                        }
277                        case EOF:
278                        case RPAR:
279                        {
280                                break;
281                        }
282                        default:
283                        {
284                                throw new NoViableAltException(LT(1), getFilename());
285                        }
286                        }
287                        }
288                        {
289                        switch ( LA(1)) {
290                        case RPAR:
291                        {
292                                match(RPAR);
293                                break;
294                        }
295                        case EOF:
296                        {
297                                break;
298                        }
299                        default:
300                        {
301                                throw new NoViableAltException(LT(1), getFilename());
302                        }
303                        }
304                        }
305                        break;
306                }
307                case EOF:
308                {
309                        break;
310                }
311                default:
312                {
313                        throw new NoViableAltException(LT(1), getFilename());
314                }
315                }
316                }
317                }
318                return noidlen;
319        }
320        
321/**
322     * noidlen = numericoid [ LCURLY len RCURLY ]
323     * len = number
324     */
325        public final AntlrSchemaParser.NoidLen  quirksNoidlen() throws RecognitionException, TokenStreamException {
326                AntlrSchemaParser.NoidLen noidlen = new AntlrSchemaParser.NoidLen();
327                
328                Token  q2 = null;
329                Token  d4 = null;
330                Token  n2 = null;
331                Token  l = null;
332                
333                matchedProduction( "AntlrSchemaValueParser.quirksNoidlen()" );
334                
335                
336                {
337                {
338                switch ( LA(1)) {
339                case LPAR:
340                {
341                        match(LPAR);
342                        break;
343                }
344                case WHSP:
345                case NUMERICOID:
346                case DESCR:
347                case QUIRKS_DESCR:
348                case QUOTE:
349                {
350                        break;
351                }
352                default:
353                {
354                        throw new NoViableAltException(LT(1), getFilename());
355                }
356                }
357                }
358                {
359                switch ( LA(1)) {
360                case WHSP:
361                {
362                        match(WHSP);
363                        break;
364                }
365                case NUMERICOID:
366                case DESCR:
367                case QUIRKS_DESCR:
368                case QUOTE:
369                {
370                        break;
371                }
372                default:
373                {
374                        throw new NoViableAltException(LT(1), getFilename());
375                }
376                }
377                }
378                {
379                switch ( LA(1)) {
380                case QUOTE:
381                {
382                        match(QUOTE);
383                        break;
384                }
385                case NUMERICOID:
386                case DESCR:
387                case QUIRKS_DESCR:
388                {
389                        break;
390                }
391                default:
392                {
393                        throw new NoViableAltException(LT(1), getFilename());
394                }
395                }
396                }
397                {
398                switch ( LA(1)) {
399                case QUIRKS_DESCR:
400                {
401                        {
402                        q2 = LT(1);
403                        match(QUIRKS_DESCR);
404                        noidlen.noid = q2.getText();
405                        }
406                        break;
407                }
408                case DESCR:
409                {
410                        {
411                        d4 = LT(1);
412                        match(DESCR);
413                        noidlen.noid = d4.getText();
414                        }
415                        break;
416                }
417                case NUMERICOID:
418                {
419                        {
420                        n2 = LT(1);
421                        match(NUMERICOID);
422                        noidlen.noid = n2.getText();
423                        }
424                        break;
425                }
426                default:
427                {
428                        throw new NoViableAltException(LT(1), getFilename());
429                }
430                }
431                }
432                {
433                switch ( LA(1)) {
434                case QUOTE:
435                {
436                        match(QUOTE);
437                        break;
438                }
439                case EOF:
440                case WHSP:
441                case RPAR:
442                case LEN:
443                {
444                        break;
445                }
446                default:
447                {
448                        throw new NoViableAltException(LT(1), getFilename());
449                }
450                }
451                }
452                {
453                switch ( LA(1)) {
454                case WHSP:
455                {
456                        match(WHSP);
457                        break;
458                }
459                case EOF:
460                case RPAR:
461                case LEN:
462                {
463                        break;
464                }
465                default:
466                {
467                        throw new NoViableAltException(LT(1), getFilename());
468                }
469                }
470                }
471                {
472                switch ( LA(1)) {
473                case RPAR:
474                {
475                        match(RPAR);
476                        break;
477                }
478                case EOF:
479                case LEN:
480                {
481                        break;
482                }
483                default:
484                {
485                        throw new NoViableAltException(LT(1), getFilename());
486                }
487                }
488                }
489                {
490                switch ( LA(1)) {
491                case LEN:
492                {
493                        l = LT(1);
494                        match(LEN);
495                        noidlen.len = Long.parseLong(l.getText());
496                        {
497                        switch ( LA(1)) {
498                        case QUOTE:
499                        {
500                                match(QUOTE);
501                                break;
502                        }
503                        case EOF:
504                        case WHSP:
505                        case RPAR:
506                        {
507                                break;
508                        }
509                        default:
510                        {
511                                throw new NoViableAltException(LT(1), getFilename());
512                        }
513                        }
514                        }
515                        {
516                        switch ( LA(1)) {
517                        case WHSP:
518                        {
519                                match(WHSP);
520                                break;
521                        }
522                        case EOF:
523                        case RPAR:
524                        {
525                                break;
526                        }
527                        default:
528                        {
529                                throw new NoViableAltException(LT(1), getFilename());
530                        }
531                        }
532                        }
533                        {
534                        switch ( LA(1)) {
535                        case RPAR:
536                        {
537                                match(RPAR);
538                                break;
539                        }
540                        case EOF:
541                        {
542                                break;
543                        }
544                        default:
545                        {
546                                throw new NoViableAltException(LT(1), getFilename());
547                        }
548                        }
549                        }
550                        break;
551                }
552                case EOF:
553                {
554                        break;
555                }
556                default:
557                {
558                        throw new NoViableAltException(LT(1), getFilename());
559                }
560                }
561                }
562                }
563                return noidlen;
564        }
565        
566/**
567     * numericoid = number 1*( DOT number )
568     */
569        public final String  numericoid() throws RecognitionException, TokenStreamException {
570                String numericoid=null;
571                
572                Token  n1 = null;
573                Token  n2 = null;
574                
575                matchedProduction( "AntlrSchemaValueParser.numericoid()" );
576                
577                
578                {
579                {
580                switch ( LA(1)) {
581                case WHSP:
582                {
583                        match(WHSP);
584                        break;
585                }
586                case LPAR:
587                case NUMERICOID:
588                case QUOTE:
589                {
590                        break;
591                }
592                default:
593                {
594                        throw new NoViableAltException(LT(1), getFilename());
595                }
596                }
597                }
598                {
599                switch ( LA(1)) {
600                case LPAR:
601                {
602                        match(LPAR);
603                        {
604                        switch ( LA(1)) {
605                        case WHSP:
606                        {
607                                match(WHSP);
608                                break;
609                        }
610                        case NUMERICOID:
611                        case QUOTE:
612                        {
613                                break;
614                        }
615                        default:
616                        {
617                                throw new NoViableAltException(LT(1), getFilename());
618                        }
619                        }
620                        }
621                        break;
622                }
623                case NUMERICOID:
624                case QUOTE:
625                {
626                        break;
627                }
628                default:
629                {
630                        throw new NoViableAltException(LT(1), getFilename());
631                }
632                }
633                }
634                {
635                switch ( LA(1)) {
636                case QUOTE:
637                {
638                        {
639                        match(QUOTE);
640                        n1 = LT(1);
641                        match(NUMERICOID);
642                        numericoid = n1.getText();
643                        match(QUOTE);
644                        }
645                        break;
646                }
647                case NUMERICOID:
648                {
649                        {
650                        n2 = LT(1);
651                        match(NUMERICOID);
652                        numericoid = n2.getText();
653                        }
654                        break;
655                }
656                default:
657                {
658                        throw new NoViableAltException(LT(1), getFilename());
659                }
660                }
661                }
662                {
663                {
664                switch ( LA(1)) {
665                case WHSP:
666                {
667                        match(WHSP);
668                        break;
669                }
670                case EOF:
671                case RPAR:
672                {
673                        break;
674                }
675                default:
676                {
677                        throw new NoViableAltException(LT(1), getFilename());
678                }
679                }
680                }
681                {
682                switch ( LA(1)) {
683                case RPAR:
684                {
685                        match(RPAR);
686                        break;
687                }
688                case EOF:
689                {
690                        break;
691                }
692                default:
693                {
694                        throw new NoViableAltException(LT(1), getFilename());
695                }
696                }
697                }
698                }
699                }
700                return numericoid;
701        }
702        
703/**
704     * oid = descr / numericoid
705     * numericoid = number 1*( DOT number )
706     * descr = keystring
707     * keystring = leadkeychar *keychar
708     * leadkeychar = ALPHA
709     * keychar = ALPHA / DIGIT / HYPHEN
710     * number  = DIGIT / ( LDIGIT 1*DIGIT )
711     *
712     */
713        public final String  oid() throws RecognitionException, TokenStreamException {
714                String oid=null;
715                
716                Token  n1 = null;
717                Token  n2 = null;
718                Token  d1 = null;
719                Token  d2 = null;
720                
721                matchedProduction( "AntlrSchemaValueParser.oid()" );
722                
723                
724                {
725                {
726                switch ( LA(1)) {
727                case WHSP:
728                {
729                        match(WHSP);
730                        break;
731                }
732                case NUMERICOID:
733                case DESCR:
734                case QUOTE:
735                {
736                        break;
737                }
738                default:
739                {
740                        throw new NoViableAltException(LT(1), getFilename());
741                }
742                }
743                }
744                {
745                switch ( LA(1)) {
746                case NUMERICOID:
747                {
748                        {
749                        n2 = LT(1);
750                        match(NUMERICOID);
751                        oid = n2.getText();
752                        }
753                        break;
754                }
755                case DESCR:
756                {
757                        {
758                        d2 = LT(1);
759                        match(DESCR);
760                        oid = d2.getText();
761                        }
762                        break;
763                }
764                default:
765                        if ((LA(1)==QUOTE) && (LA(2)==NUMERICOID)) {
766                                {
767                                match(QUOTE);
768                                n1 = LT(1);
769                                match(NUMERICOID);
770                                oid = n1.getText();
771                                match(QUOTE);
772                                }
773                        }
774                        else if ((LA(1)==QUOTE) && (LA(2)==DESCR)) {
775                                {
776                                match(QUOTE);
777                                d1 = LT(1);
778                                match(DESCR);
779                                oid = d1.getText();
780                                match(QUOTE);
781                                }
782                        }
783                else {
784                        throw new NoViableAltException(LT(1), getFilename());
785                }
786                }
787                }
788                {
789                if ((LA(1)==WHSP) && (_tokenSet_0.member(LA(2))) && (_tokenSet_0.member(LA(3)))) {
790                        match(WHSP);
791                }
792                else if ((_tokenSet_0.member(LA(1))) && (_tokenSet_0.member(LA(2))) && (_tokenSet_0.member(LA(3)))) {
793                }
794                else {
795                        throw new NoViableAltException(LT(1), getFilename());
796                }
797                
798                }
799                }
800                return oid;
801        }
802        
803/**
804     * oids = oid / ( LPAREN WSP oidlist WSP RPAREN )
805     * oidlist = oid *( WSP DOLLAR WSP oid )
806     */
807        public final List<String>  oids() throws RecognitionException, TokenStreamException {
808                List<String> oids;
809                
810                
811                matchedProduction( "AntlrSchemaValueParser.oids()" );
812                oids = new ArrayList<String>();
813                String oid = null;
814                
815                
816                {
817                switch ( LA(1)) {
818                case WHSP:
819                case NUMERICOID:
820                case DESCR:
821                case QUOTE:
822                {
823                        {
824                        oid=oid();
825                        oids.add(oid);
826                        }
827                        break;
828                }
829                case LPAR:
830                {
831                        {
832                        match(LPAR);
833                        oid=oid();
834                        oids.add(oid);
835                        {
836                        _loop107:
837                        do {
838                                if ((_tokenSet_1.member(LA(1)))) {
839                                        {
840                                        switch ( LA(1)) {
841                                        case DOLLAR:
842                                        {
843                                                match(DOLLAR);
844                                                break;
845                                        }
846                                        case WHSP:
847                                        case NUMERICOID:
848                                        case DESCR:
849                                        case QUOTE:
850                                        {
851                                                break;
852                                        }
853                                        default:
854                                        {
855                                                throw new NoViableAltException(LT(1), getFilename());
856                                        }
857                                        }
858                                        }
859                                        oid=oid();
860                                        oids.add(oid);
861                                }
862                                else {
863                                        break _loop107;
864                                }
865                                
866                        } while (true);
867                        }
868                        match(RPAR);
869                        }
870                        break;
871                }
872                default:
873                {
874                        throw new NoViableAltException(LT(1), getFilename());
875                }
876                }
877                }
878                return oids;
879        }
880        
881/**
882     * qdescr = SQUOTE descr SQUOTE
883     */
884        public final String  qdescr() throws RecognitionException, TokenStreamException {
885                String qdescr=null;
886                
887                Token  d1 = null;
888                Token  d2 = null;
889                
890                matchedProduction( "AntlrSchemaValueParser.qdescr()" );
891                
892                
893                {
894                {
895                switch ( LA(1)) {
896                case WHSP:
897                {
898                        match(WHSP);
899                        break;
900                }
901                case DESCR:
902                case QUOTE:
903                {
904                        break;
905                }
906                default:
907                {
908                        throw new NoViableAltException(LT(1), getFilename());
909                }
910                }
911                }
912                {
913                switch ( LA(1)) {
914                case QUOTE:
915                {
916                        {
917                        match(QUOTE);
918                        d1 = LT(1);
919                        match(DESCR);
920                        qdescr = d1.getText();
921                        match(QUOTE);
922                        }
923                        break;
924                }
925                case DESCR:
926                {
927                        {
928                        d2 = LT(1);
929                        match(DESCR);
930                        qdescr = d2.getText();
931                        }
932                        break;
933                }
934                default:
935                {
936                        throw new NoViableAltException(LT(1), getFilename());
937                }
938                }
939                }
940                }
941                return qdescr;
942        }
943        
944/**
945     * qdescrs = qdescr / ( LPAREN WSP qdescrlist WSP RPAREN )
946     * qdescrlist = [ qdescr *( SP qdescr ) ]
947     */
948        public final List<String>  qdescrs() throws RecognitionException, TokenStreamException {
949                List<String> qdescrs;
950                
951                
952                matchedProduction( "AntlrSchemaValueParser.qdescrs()" );
953                qdescrs = new ArrayList<String>();
954                String qdescr = null;
955                
956                
957                {
958                switch ( LA(1)) {
959                case WHSP:
960                case DESCR:
961                case QUOTE:
962                {
963                        {
964                        qdescr=qdescr();
965                        qdescrs.add(qdescr);
966                        }
967                        break;
968                }
969                case LPAR:
970                {
971                        {
972                        match(LPAR);
973                        qdescr=qdescr();
974                        qdescrs.add(qdescr);
975                        {
976                        if ((LA(1)==WHSP) && (_tokenSet_2.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
977                                match(WHSP);
978                        }
979                        else if ((_tokenSet_2.member(LA(1))) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
980                        }
981                        else {
982                                throw new NoViableAltException(LT(1), getFilename());
983                        }
984                        
985                        }
986                        {
987                        switch ( LA(1)) {
988                        case DOLLAR:
989                        {
990                                match(DOLLAR);
991                                break;
992                        }
993                        case WHSP:
994                        case RPAR:
995                        case DESCR:
996                        case QUOTE:
997                        {
998                                break;
999                        }
1000                        default:
1001                        {
1002                                throw new NoViableAltException(LT(1), getFilename());
1003                        }
1004                        }
1005                        }
1006                        {
1007                        if ((LA(1)==WHSP) && (_tokenSet_4.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
1008                                match(WHSP);
1009                        }
1010                        else if ((_tokenSet_4.member(LA(1))) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
1011                        }
1012                        else {
1013                                throw new NoViableAltException(LT(1), getFilename());
1014                        }
1015                        
1016                        }
1017                        {
1018                        _loop125:
1019                        do {
1020                                if ((LA(1)==WHSP||LA(1)==DESCR||LA(1)==QUOTE)) {
1021                                        qdescr=qdescr();
1022                                        qdescrs.add(qdescr);
1023                                        {
1024                                        if ((LA(1)==WHSP) && (_tokenSet_2.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
1025                                                match(WHSP);
1026                                        }
1027                                        else if ((_tokenSet_2.member(LA(1))) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
1028                                        }
1029                                        else {
1030                                                throw new NoViableAltException(LT(1), getFilename());
1031                                        }
1032                                        
1033                                        }
1034                                        {
1035                                        switch ( LA(1)) {
1036                                        case DOLLAR:
1037                                        {
1038                                                match(DOLLAR);
1039                                                break;
1040                                        }
1041                                        case WHSP:
1042                                        case RPAR:
1043                                        case DESCR:
1044                                        case QUOTE:
1045                                        {
1046                                                break;
1047                                        }
1048                                        default:
1049                                        {
1050                                                throw new NoViableAltException(LT(1), getFilename());
1051                                        }
1052                                        }
1053                                        }
1054                                        {
1055                                        if ((LA(1)==WHSP) && (_tokenSet_4.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
1056                                                match(WHSP);
1057                                        }
1058                                        else if ((_tokenSet_4.member(LA(1))) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
1059                                        }
1060                                        else {
1061                                                throw new NoViableAltException(LT(1), getFilename());
1062                                        }
1063                                        
1064                                        }
1065                                }
1066                                else {
1067                                        break _loop125;
1068                                }
1069                                
1070                        } while (true);
1071                        }
1072                        match(RPAR);
1073                        }
1074                        break;
1075                }
1076                default:
1077                {
1078                        throw new NoViableAltException(LT(1), getFilename());
1079                }
1080                }
1081                }
1082                return qdescrs;
1083        }
1084        
1085/**
1086     * qdescr = SQUOTE descr SQUOTE
1087     */
1088        public final String  quirksQdescr() throws RecognitionException, TokenStreamException {
1089                String qdescr=null;
1090                
1091                Token  d1 = null;
1092                Token  d2 = null;
1093                Token  d3 = null;
1094                Token  d4 = null;
1095                Token  n1 = null;
1096                Token  n2 = null;
1097                
1098                matchedProduction( "AntlrSchemaValueParser.qdescr()" );
1099                
1100                
1101                {
1102                {
1103                switch ( LA(1)) {
1104                case WHSP:
1105                {
1106                        match(WHSP);
1107                        break;
1108                }
1109                case NUMERICOID:
1110                case DESCR:
1111                case QUIRKS_DESCR:
1112                case QUOTE:
1113                {
1114                        break;
1115                }
1116                default:
1117                {
1118                        throw new NoViableAltException(LT(1), getFilename());
1119                }
1120                }
1121                }
1122                {
1123                switch ( LA(1)) {
1124                case QUIRKS_DESCR:
1125                {
1126                        {
1127                        d2 = LT(1);
1128                        match(QUIRKS_DESCR);
1129                        qdescr = d2.getText();
1130                        }
1131                        break;
1132                }
1133                case DESCR:
1134                {
1135                        {
1136                        d4 = LT(1);
1137                        match(DESCR);
1138                        qdescr = d4.getText();
1139                        }
1140                        break;
1141                }
1142                case NUMERICOID:
1143                {
1144                        {
1145                        n2 = LT(1);
1146                        match(NUMERICOID);
1147                        qdescr = n2.getText();
1148                        }
1149                        break;
1150                }
1151                default:
1152                        if ((LA(1)==QUOTE) && (LA(2)==QUIRKS_DESCR)) {
1153                                {
1154                                match(QUOTE);
1155                                d1 = LT(1);
1156                                match(QUIRKS_DESCR);
1157                                qdescr = d1.getText();
1158                                match(QUOTE);
1159                                }
1160                        }
1161                        else if ((LA(1)==QUOTE) && (LA(2)==DESCR)) {
1162                                {
1163                                match(QUOTE);
1164                                d3 = LT(1);
1165                                match(DESCR);
1166                                qdescr = d3.getText();
1167                                match(QUOTE);
1168                                }
1169                        }
1170                        else if ((LA(1)==QUOTE) && (LA(2)==NUMERICOID)) {
1171                                {
1172                                match(QUOTE);
1173                                n1 = LT(1);
1174                                match(NUMERICOID);
1175                                qdescr = n1.getText();
1176                                match(QUOTE);
1177                                }
1178                        }
1179                else {
1180                        throw new NoViableAltException(LT(1), getFilename());
1181                }
1182                }
1183                }
1184                {
1185                if ((LA(1)==WHSP) && (_tokenSet_5.member(LA(2))) && (_tokenSet_5.member(LA(3)))) {
1186                        match(WHSP);
1187                }
1188                else if ((_tokenSet_5.member(LA(1))) && (_tokenSet_5.member(LA(2))) && (_tokenSet_5.member(LA(3)))) {
1189                }
1190                else {
1191                        throw new NoViableAltException(LT(1), getFilename());
1192                }
1193                
1194                }
1195                }
1196                return qdescr;
1197        }
1198        
1199/**
1200     * qdescrs = qdescr / ( LPAREN WSP qdescrlist WSP RPAREN )
1201     * qdescrlist = [ qdescr *( SP qdescr ) ]
1202     */
1203        public final List<String>  quirksQdescrs() throws RecognitionException, TokenStreamException {
1204                List<String> qdescrs;
1205                
1206                
1207                matchedProduction( "AntlrSchemaValueParser.qdescrs()" );
1208                qdescrs = new ArrayList<String>();
1209                String qdescr = null;
1210                
1211                
1212                {
1213                switch ( LA(1)) {
1214                case WHSP:
1215                case NUMERICOID:
1216                case DESCR:
1217                case QUIRKS_DESCR:
1218                case QUOTE:
1219                {
1220                        {
1221                        qdescr=quirksQdescr();
1222                        qdescrs.add(qdescr);
1223                        }
1224                        break;
1225                }
1226                case LPAR:
1227                {
1228                        {
1229                        match(LPAR);
1230                        qdescr=quirksQdescr();
1231                        qdescrs.add(qdescr);
1232                        {
1233                        if ((LA(1)==WHSP) && (_tokenSet_6.member(LA(2))) && (_tokenSet_5.member(LA(3)))) {
1234                                match(WHSP);
1235                        }
1236                        else if ((_tokenSet_6.member(LA(1))) && (_tokenSet_5.member(LA(2))) && (_tokenSet_5.member(LA(3)))) {
1237                        }
1238                        else {
1239                                throw new NoViableAltException(LT(1), getFilename());
1240                        }
1241                        
1242                        }
1243                        {
1244                        switch ( LA(1)) {
1245                        case DOLLAR:
1246                        {
1247                                match(DOLLAR);
1248                                break;
1249                        }
1250                        case WHSP:
1251                        case RPAR:
1252                        case NUMERICOID:
1253                        case DESCR:
1254                        case QUIRKS_DESCR:
1255                        case QUOTE:
1256                        {
1257                                break;
1258                        }
1259                        default:
1260                        {
1261                                throw new NoViableAltException(LT(1), getFilename());
1262                        }
1263                        }
1264                        }
1265                        {
1266                        if ((LA(1)==WHSP) && (_tokenSet_7.member(LA(2))) && (_tokenSet_5.member(LA(3)))) {
1267                                match(WHSP);
1268                        }
1269                        else if ((_tokenSet_7.member(LA(1))) && (_tokenSet_5.member(LA(2))) && (_tokenSet_5.member(LA(3)))) {
1270                        }
1271                        else {
1272                                throw new NoViableAltException(LT(1), getFilename());
1273                        }
1274                        
1275                        }
1276                        {
1277                        _loop148:
1278                        do {
1279                                if ((_tokenSet_8.member(LA(1)))) {
1280                                        qdescr=quirksQdescr();
1281                                        qdescrs.add(qdescr);
1282                                        {
1283                                        if ((LA(1)==WHSP) && (_tokenSet_6.member(LA(2))) && (_tokenSet_5.member(LA(3)))) {
1284                                                match(WHSP);
1285                                        }
1286                                        else if ((_tokenSet_6.member(LA(1))) && (_tokenSet_5.member(LA(2))) && (_tokenSet_5.member(LA(3)))) {
1287                                        }
1288                                        else {
1289                                                throw new NoViableAltException(LT(1), getFilename());
1290                                        }
1291                                        
1292                                        }
1293                                        {
1294                                        switch ( LA(1)) {
1295                                        case DOLLAR:
1296                                        {
1297                                                match(DOLLAR);
1298                                                break;
1299                                        }
1300                                        case WHSP:
1301                                        case RPAR:
1302                                        case NUMERICOID:
1303                                        case DESCR:
1304                                        case QUIRKS_DESCR:
1305                                        case QUOTE:
1306                                        {
1307                                                break;
1308                                        }
1309                                        default:
1310                                        {
1311                                                throw new NoViableAltException(LT(1), getFilename());
1312                                        }
1313                                        }
1314                                        }
1315                                        {
1316                                        if ((LA(1)==WHSP) && (_tokenSet_7.member(LA(2))) && (_tokenSet_5.member(LA(3)))) {
1317                                                match(WHSP);
1318                                        }
1319                                        else if ((_tokenSet_7.member(LA(1))) && (_tokenSet_5.member(LA(2))) && (_tokenSet_5.member(LA(3)))) {
1320                                        }
1321                                        else {
1322                                                throw new NoViableAltException(LT(1), getFilename());
1323                                        }
1324                                        
1325                                        }
1326                                }
1327                                else {
1328                                        break _loop148;
1329                                }
1330                                
1331                        } while (true);
1332                        }
1333                        match(RPAR);
1334                        }
1335                        break;
1336                }
1337                default:
1338                {
1339                        throw new NoViableAltException(LT(1), getFilename());
1340                }
1341                }
1342                }
1343                return qdescrs;
1344        }
1345        
1346/**
1347     * ruleid = number
1348     * number  = DIGIT / ( LDIGIT 1*DIGIT )
1349     *
1350     */
1351        public final Integer  ruleid() throws RecognitionException, TokenStreamException {
1352                Integer ruleid=null;
1353                
1354                Token  n = null;
1355                
1356                matchedProduction( "AntlrSchemaValueParser.ruleid()" );
1357                
1358                
1359                {
1360                {
1361                switch ( LA(1)) {
1362                case WHSP:
1363                {
1364                        match(WHSP);
1365                        break;
1366                }
1367                case NUMBER:
1368                {
1369                        break;
1370                }
1371                default:
1372                {
1373                        throw new NoViableAltException(LT(1), getFilename());
1374                }
1375                }
1376                }
1377                n = LT(1);
1378                match(NUMBER);
1379                ruleid = Integer.parseInt(n.getText());
1380                }
1381                return ruleid;
1382        }
1383        
1384/**
1385     * ruleids = ruleid / ( LPAREN WSP ruleidlist WSP RPAREN )
1386     * ruleidlist = ruleid *( SP ruleid )
1387     */
1388        public final List<Integer>  ruleids() throws RecognitionException, TokenStreamException {
1389                List<Integer> ruleids;
1390                
1391                
1392                matchedProduction( "AntlrSchemaValueParser.ruleids()" );
1393                ruleids = new ArrayList<Integer>();
1394                Integer ruleid = null;
1395                
1396                
1397                {
1398                switch ( LA(1)) {
1399                case WHSP:
1400                case NUMBER:
1401                {
1402                        {
1403                        ruleid=ruleid();
1404                        ruleids.add(ruleid);
1405                        }
1406                        break;
1407                }
1408                case LPAR:
1409                {
1410                        {
1411                        match(LPAR);
1412                        ruleid=ruleid();
1413                        ruleids.add(ruleid);
1414                        {
1415                        _loop157:
1416                        do {
1417                                if ((LA(1)==WHSP) && (LA(2)==WHSP||LA(2)==NUMBER)) {
1418                                        match(WHSP);
1419                                        ruleid=ruleid();
1420                                        ruleids.add(ruleid);
1421                                }
1422                                else {
1423                                        break _loop157;
1424                                }
1425                                
1426                        } while (true);
1427                        }
1428                        {
1429                        switch ( LA(1)) {
1430                        case WHSP:
1431                        {
1432                                match(WHSP);
1433                                break;
1434                        }
1435                        case RPAR:
1436                        {
1437                                break;
1438                        }
1439                        default:
1440                        {
1441                                throw new NoViableAltException(LT(1), getFilename());
1442                        }
1443                        }
1444                        }
1445                        match(RPAR);
1446                        }
1447                        break;
1448                }
1449                default:
1450                {
1451                        throw new NoViableAltException(LT(1), getFilename());
1452                }
1453                }
1454                }
1455                return ruleids;
1456        }
1457        
1458        
1459        public static final String[] _tokenNames = {
1460                "<0>",
1461                "EOF",
1462                "<2>",
1463                "NULL_TREE_LOOKAHEAD",
1464                "WHSP",
1465                "LPAR",
1466                "RPAR",
1467                "CHAR",
1468                "LDIGIT",
1469                "DIGIT",
1470                "NUMBER",
1471                "NUMBER2",
1472                "NUMERICOID",
1473                "HYPEN",
1474                "OTHER",
1475                "DESCR",
1476                "QUIRKS_DESCR",
1477                "QUOTE",
1478                "DOLLAR",
1479                "LCURLY",
1480                "RCURLY",
1481                "LEN",
1482                "DESCR_OR_QUIRKS_DESCR"
1483        };
1484        
1485        private static final long[] mk_tokenSet_0() {
1486                long[] data = { 430162L, 0L};
1487                return data;
1488        }
1489        public static final BitSet _tokenSet_0 = new BitSet(mk_tokenSet_0());
1490        private static final long[] mk_tokenSet_1() {
1491                long[] data = { 430096L, 0L};
1492                return data;
1493        }
1494        public static final BitSet _tokenSet_1 = new BitSet(mk_tokenSet_1());
1495        private static final long[] mk_tokenSet_2() {
1496                long[] data = { 426064L, 0L};
1497                return data;
1498        }
1499        public static final BitSet _tokenSet_2 = new BitSet(mk_tokenSet_2());
1500        private static final long[] mk_tokenSet_3() {
1501                long[] data = { 426066L, 0L};
1502                return data;
1503        }
1504        public static final BitSet _tokenSet_3 = new BitSet(mk_tokenSet_3());
1505        private static final long[] mk_tokenSet_4() {
1506                long[] data = { 163920L, 0L};
1507                return data;
1508        }
1509        public static final BitSet _tokenSet_4 = new BitSet(mk_tokenSet_4());
1510        private static final long[] mk_tokenSet_5() {
1511                long[] data = { 495698L, 0L};
1512                return data;
1513        }
1514        public static final BitSet _tokenSet_5 = new BitSet(mk_tokenSet_5());
1515        private static final long[] mk_tokenSet_6() {
1516                long[] data = { 495696L, 0L};
1517                return data;
1518        }
1519        public static final BitSet _tokenSet_6 = new BitSet(mk_tokenSet_6());
1520        private static final long[] mk_tokenSet_7() {
1521                long[] data = { 233552L, 0L};
1522                return data;
1523        }
1524        public static final BitSet _tokenSet_7 = new BitSet(mk_tokenSet_7());
1525        private static final long[] mk_tokenSet_8() {
1526                long[] data = { 233488L, 0L};
1527                return data;
1528        }
1529        public static final BitSet _tokenSet_8 = new BitSet(mk_tokenSet_8());
1530        
1531        }