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