1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24 package org.apache.directory.api.ldap.model.subtree;
25
26 import org.apache.directory.api.ldap.model.name.Dn;
27 import org.apache.directory.api.ldap.model.filter.ExprNode;
28 import org.apache.directory.api.ldap.model.filter.LeafNode;
29 import org.apache.directory.api.ldap.model.filter.BranchNode;
30 import org.apache.directory.api.ldap.model.filter.AndNode;
31 import org.apache.directory.api.ldap.model.filter.OrNode;
32 import org.apache.directory.api.ldap.model.filter.NotNode;
33 import org.apache.directory.api.ldap.model.filter.EqualityNode;
34 import org.apache.directory.api.ldap.model.filter.FilterParser;
35 import org.apache.directory.api.util.ComponentsMonitor;
36 import org.apache.directory.api.util.OptionalComponentsMonitor;
37 import org.apache.directory.api.ldap.model.schema.SchemaManager;
38
39 import org.slf4j.Logger;
40 import org.slf4j.LoggerFactory;
41
42 import antlr.TokenBuffer;
43 import antlr.TokenStreamException;
44 import antlr.TokenStreamIOException;
45 import antlr.ANTLRException;
46 import antlr.LLkParser;
47 import antlr.Token;
48 import antlr.TokenStream;
49 import antlr.RecognitionException;
50 import antlr.NoViableAltException;
51 import antlr.MismatchedTokenException;
52 import antlr.SemanticException;
53 import antlr.ParserSharedInputState;
54 import antlr.collections.impl.BitSet;
55
56
57
58
59
60
61
62 public class AntlrSubtreeSpecificationChecker extends antlr.LLkParser implements AntlrSubtreeSpecificationCheckerTokenTypes
63 {
64
65 private static final Logger log = LoggerFactory.getLogger( AntlrSubtreeSpecificationChecker.class );
66
67 private ComponentsMonitor subtreeSpecificationComponentsMonitor = null;
68
69
70 private SchemaManager schemaManager;
71
72
73
74
75 public void init( SchemaManager schemaManager )
76 {
77 this.schemaManager = schemaManager;
78 }
79
80
81 private int token2Integer( Token token ) throws RecognitionException
82 {
83 int i = 0;
84
85 try
86 {
87 i = Integer.parseInt( token.getText());
88 }
89 catch ( NumberFormatException e )
90 {
91 throw new RecognitionException( "Value of INTEGER token " +
92 token.getText() +
93 " cannot be converted to an Integer" );
94 }
95
96 return i;
97 }
98
99 protected AntlrSubtreeSpecificationChecker(TokenBuffer tokenBuf, int k) {
100 super(tokenBuf,k);
101 tokenNames = _tokenNames;
102 }
103
104 public AntlrSubtreeSpecificationChecker(TokenBuffer tokenBuf) {
105 this(tokenBuf,1);
106 }
107
108 protected AntlrSubtreeSpecificationChecker(TokenStream lexer, int k) {
109 super(lexer,k);
110 tokenNames = _tokenNames;
111 }
112
113 public AntlrSubtreeSpecificationChecker(TokenStream lexer) {
114 this(lexer,1);
115 }
116
117 public AntlrSubtreeSpecificationChecker(ParserSharedInputState state) {
118 super(state,1);
119 tokenNames = _tokenNames;
120 }
121
122 public final void wrapperEntryPoint() throws RecognitionException, TokenStreamException {
123
124
125 log.debug( "entered wrapperEntryPoint()" );
126
127
128 subtreeSpecification();
129 match(LITERAL_end);
130 }
131
132 public final void subtreeSpecification() throws RecognitionException, TokenStreamException {
133
134
135 log.debug( "entered subtreeSpecification()" );
136 subtreeSpecificationComponentsMonitor = new OptionalComponentsMonitor(
137 new String [] { "base", "specificExclusions", "minimum", "maximum", "specificationFilter" } );
138
139
140 match(OPEN_CURLY);
141 {
142 _loop4:
143 do {
144 if ((LA(1)==SP)) {
145 match(SP);
146 }
147 else {
148 break _loop4;
149 }
150
151 } while (true);
152 }
153 {
154 switch ( LA(1)) {
155 case ID_base:
156 case ID_specificExclusions:
157 case ID_minimum:
158 case ID_maximum:
159 case ID_specificationFilter:
160 {
161 subtreeSpecificationComponent();
162 {
163 _loop7:
164 do {
165 if ((LA(1)==SP)) {
166 match(SP);
167 }
168 else {
169 break _loop7;
170 }
171
172 } while (true);
173 }
174 {
175 _loop13:
176 do {
177 if ((LA(1)==SEP)) {
178 match(SEP);
179 {
180 _loop10:
181 do {
182 if ((LA(1)==SP)) {
183 match(SP);
184 }
185 else {
186 break _loop10;
187 }
188
189 } while (true);
190 }
191 subtreeSpecificationComponent();
192 {
193 _loop12:
194 do {
195 if ((LA(1)==SP)) {
196 match(SP);
197 }
198 else {
199 break _loop12;
200 }
201
202 } while (true);
203 }
204 }
205 else {
206 break _loop13;
207 }
208
209 } while (true);
210 }
211 break;
212 }
213 case CLOSE_CURLY:
214 {
215 break;
216 }
217 default:
218 {
219 throw new NoViableAltException(LT(1), getFilename());
220 }
221 }
222 }
223 match(CLOSE_CURLY);
224 }
225
226 public final void subtreeSpecificationComponent() throws RecognitionException, TokenStreamException {
227
228
229 log.debug( "entered subtreeSpecification()" );
230
231
232 try {
233 switch ( LA(1)) {
234 case ID_base:
235 {
236 ss_base();
237
238 subtreeSpecificationComponentsMonitor.useComponent( "base" );
239
240 break;
241 }
242 case ID_specificExclusions:
243 {
244 ss_specificExclusions();
245
246 subtreeSpecificationComponentsMonitor.useComponent( "specificExclusions" );
247
248 break;
249 }
250 case ID_minimum:
251 {
252 ss_minimum();
253
254 subtreeSpecificationComponentsMonitor.useComponent( "minimum" );
255
256 break;
257 }
258 case ID_maximum:
259 {
260 ss_maximum();
261
262 subtreeSpecificationComponentsMonitor.useComponent( "maximum" );
263
264 break;
265 }
266 case ID_specificationFilter:
267 {
268 ss_specificationFilter();
269
270 subtreeSpecificationComponentsMonitor.useComponent( "specificationFilter" );
271
272 break;
273 }
274 default:
275 {
276 throw new NoViableAltException(LT(1), getFilename());
277 }
278 }
279 }
280 catch (IllegalArgumentException e) {
281
282 throw new RecognitionException( e.getMessage() );
283
284 }
285 }
286
287 public final void ss_base() throws RecognitionException, TokenStreamException {
288
289
290 log.debug( "entered ss_base()" );
291
292
293 match(ID_base);
294 {
295 int _cnt17=0;
296 _loop17:
297 do {
298 if ((LA(1)==SP)) {
299 match(SP);
300 }
301 else {
302 if ( _cnt17>=1 ) { break _loop17; } else {throw new NoViableAltException(LT(1), getFilename());}
303 }
304
305 _cnt17++;
306 } while (true);
307 }
308 distinguishedName();
309 }
310
311 public final void ss_specificExclusions() throws RecognitionException, TokenStreamException {
312
313
314 log.debug( "entered ss_specificExclusions()" );
315
316
317 match(ID_specificExclusions);
318 {
319 int _cnt20=0;
320 _loop20:
321 do {
322 if ((LA(1)==SP)) {
323 match(SP);
324 }
325 else {
326 if ( _cnt20>=1 ) { break _loop20; } else {throw new NoViableAltException(LT(1), getFilename());}
327 }
328
329 _cnt20++;
330 } while (true);
331 }
332 specificExclusions();
333 }
334
335 public final void ss_minimum() throws RecognitionException, TokenStreamException {
336
337
338 log.debug( "entered ss_minimum()" );
339
340
341 match(ID_minimum);
342 {
343 int _cnt46=0;
344 _loop46:
345 do {
346 if ((LA(1)==SP)) {
347 match(SP);
348 }
349 else {
350 if ( _cnt46>=1 ) { break _loop46; } else {throw new NoViableAltException(LT(1), getFilename());}
351 }
352
353 _cnt46++;
354 } while (true);
355 }
356 baseDistance();
357 }
358
359 public final void ss_maximum() throws RecognitionException, TokenStreamException {
360
361
362 log.debug( "entered ss_maximum()" );
363
364
365 match(ID_maximum);
366 {
367 int _cnt49=0;
368 _loop49:
369 do {
370 if ((LA(1)==SP)) {
371 match(SP);
372 }
373 else {
374 if ( _cnt49>=1 ) { break _loop49; } else {throw new NoViableAltException(LT(1), getFilename());}
375 }
376
377 _cnt49++;
378 } while (true);
379 }
380 baseDistance();
381 }
382
383 public final void ss_specificationFilter() throws RecognitionException, TokenStreamException {
384
385
386 log.debug( "entered ss_specificationFilter()" );
387
388
389 match(ID_specificationFilter);
390 {
391 int _cnt52=0;
392 _loop52:
393 do {
394 if ((LA(1)==SP)) {
395 match(SP);
396 }
397 else {
398 if ( _cnt52>=1 ) { break _loop52; } else {throw new NoViableAltException(LT(1), getFilename());}
399 }
400
401 _cnt52++;
402 } while (true);
403 }
404 {
405 switch ( LA(1)) {
406 case ID_item:
407 case ID_and:
408 case ID_or:
409 case ID_not:
410 {
411 {
412 refinement();
413 }
414 break;
415 }
416 case FILTER:
417 {
418 {
419 filter();
420 }
421 break;
422 }
423 default:
424 {
425 throw new NoViableAltException(LT(1), getFilename());
426 }
427 }
428 }
429 }
430
431 public final void distinguishedName() throws RecognitionException, TokenStreamException {
432
433 Token token = null;
434
435 log.debug( "entered distinguishedName()" );
436
437
438 try {
439 token = LT(1);
440 match(SAFEUTF8STRING);
441
442 new Dn( token.getText() );
443 log.debug( "recognized a DistinguishedName: " + token.getText() );
444
445 }
446 catch (Exception e) {
447
448 throw new RecognitionException( "dnParser failed for " + token.getText() + " " + e.getMessage() );
449
450 }
451 }
452
453 public final void specificExclusions() throws RecognitionException, TokenStreamException {
454
455
456 log.debug( "entered specificExclusions()" );
457
458
459 match(OPEN_CURLY);
460 {
461 _loop23:
462 do {
463 if ((LA(1)==SP)) {
464 match(SP);
465 }
466 else {
467 break _loop23;
468 }
469
470 } while (true);
471 }
472 {
473 switch ( LA(1)) {
474 case ID_chopBefore:
475 case ID_chopAfter:
476 {
477 specificExclusion();
478 {
479 _loop26:
480 do {
481 if ((LA(1)==SP)) {
482 match(SP);
483 }
484 else {
485 break _loop26;
486 }
487
488 } while (true);
489 }
490 {
491 _loop32:
492 do {
493 if ((LA(1)==SEP)) {
494 match(SEP);
495 {
496 _loop29:
497 do {
498 if ((LA(1)==SP)) {
499 match(SP);
500 }
501 else {
502 break _loop29;
503 }
504
505 } while (true);
506 }
507 specificExclusion();
508 {
509 _loop31:
510 do {
511 if ((LA(1)==SP)) {
512 match(SP);
513 }
514 else {
515 break _loop31;
516 }
517
518 } while (true);
519 }
520 }
521 else {
522 break _loop32;
523 }
524
525 } while (true);
526 }
527 break;
528 }
529 case CLOSE_CURLY:
530 {
531 break;
532 }
533 default:
534 {
535 throw new NoViableAltException(LT(1), getFilename());
536 }
537 }
538 }
539 match(CLOSE_CURLY);
540 }
541
542 public final void specificExclusion() throws RecognitionException, TokenStreamException {
543
544
545 log.debug( "entered specificExclusion()" );
546
547
548 switch ( LA(1)) {
549 case ID_chopBefore:
550 {
551 chopBefore();
552 break;
553 }
554 case ID_chopAfter:
555 {
556 chopAfter();
557 break;
558 }
559 default:
560 {
561 throw new NoViableAltException(LT(1), getFilename());
562 }
563 }
564 }
565
566 public final void chopBefore() throws RecognitionException, TokenStreamException {
567
568
569 log.debug( "entered chopBefore()" );
570
571
572 match(ID_chopBefore);
573 {
574 _loop36:
575 do {
576 if ((LA(1)==SP)) {
577 match(SP);
578 }
579 else {
580 break _loop36;
581 }
582
583 } while (true);
584 }
585 match(COLON);
586 {
587 _loop38:
588 do {
589 if ((LA(1)==SP)) {
590 match(SP);
591 }
592 else {
593 break _loop38;
594 }
595
596 } while (true);
597 }
598 distinguishedName();
599 }
600
601 public final void chopAfter() throws RecognitionException, TokenStreamException {
602
603
604 log.debug( "entered chopAfter()" );
605
606
607 match(ID_chopAfter);
608 {
609 _loop41:
610 do {
611 if ((LA(1)==SP)) {
612 match(SP);
613 }
614 else {
615 break _loop41;
616 }
617
618 } while (true);
619 }
620 match(COLON);
621 {
622 _loop43:
623 do {
624 if ((LA(1)==SP)) {
625 match(SP);
626 }
627 else {
628 break _loop43;
629 }
630
631 } while (true);
632 }
633 distinguishedName();
634 }
635
636 public final void baseDistance() throws RecognitionException, TokenStreamException {
637
638 Token token = null;
639
640 log.debug( "entered baseDistance()" );
641
642
643 token = LT(1);
644 match(INTEGER);
645
646 token2Integer(token);
647
648 }
649
650 public final void refinement() throws RecognitionException, TokenStreamException {
651
652
653 log.debug( "entered refinement()" );
654
655
656 switch ( LA(1)) {
657 case ID_item:
658 {
659 item();
660 break;
661 }
662 case ID_and:
663 {
664 and();
665 break;
666 }
667 case ID_or:
668 {
669 or();
670 break;
671 }
672 case ID_not:
673 {
674 not();
675 break;
676 }
677 default:
678 {
679 throw new NoViableAltException(LT(1), getFilename());
680 }
681 }
682 }
683
684 public final void filter() throws RecognitionException, TokenStreamException {
685
686 Token filterToken = null;
687
688 log.debug( "entered filter()" );
689
690
691 try {
692 {
693 filterToken = LT(1);
694 match(FILTER);
695 FilterParser.parse( filterToken.getText() );
696 }
697 }
698 catch (Exception e) {
699
700 throw new RecognitionException( "filterParser failed. " + e.getMessage() );
701
702 }
703 }
704
705 public final void oid() throws RecognitionException, TokenStreamException {
706
707
708 log.debug( "entered oid()" );
709 Token token = null;
710
711
712 token = LT( 1 );
713 {
714 switch ( LA(1)) {
715 case DESCR:
716 {
717 match(DESCR);
718 break;
719 }
720 case NUMERICOID:
721 {
722 match(NUMERICOID);
723 break;
724 }
725 default:
726 {
727 throw new NoViableAltException(LT(1), getFilename());
728 }
729 }
730 }
731
732 log.debug( "recognized an oid: " + token.getText() );
733
734 }
735
736 public final void item() throws RecognitionException, TokenStreamException {
737
738
739 log.debug( "entered item()" );
740
741
742 match(ID_item);
743 {
744 _loop65:
745 do {
746 if ((LA(1)==SP)) {
747 match(SP);
748 }
749 else {
750 break _loop65;
751 }
752
753 } while (true);
754 }
755 match(COLON);
756 {
757 _loop67:
758 do {
759 if ((LA(1)==SP)) {
760 match(SP);
761 }
762 else {
763 break _loop67;
764 }
765
766 } while (true);
767 }
768 oid();
769 }
770
771 public final void and() throws RecognitionException, TokenStreamException {
772
773
774 log.debug( "entered and()" );
775
776
777 match(ID_and);
778 {
779 _loop70:
780 do {
781 if ((LA(1)==SP)) {
782 match(SP);
783 }
784 else {
785 break _loop70;
786 }
787
788 } while (true);
789 }
790 match(COLON);
791 {
792 _loop72:
793 do {
794 if ((LA(1)==SP)) {
795 match(SP);
796 }
797 else {
798 break _loop72;
799 }
800
801 } while (true);
802 }
803 refinements();
804 }
805
806 public final void or() throws RecognitionException, TokenStreamException {
807
808
809 log.debug( "entered or()" );
810
811
812 match(ID_or);
813 {
814 _loop75:
815 do {
816 if ((LA(1)==SP)) {
817 match(SP);
818 }
819 else {
820 break _loop75;
821 }
822
823 } while (true);
824 }
825 match(COLON);
826 {
827 _loop77:
828 do {
829 if ((LA(1)==SP)) {
830 match(SP);
831 }
832 else {
833 break _loop77;
834 }
835
836 } while (true);
837 }
838 refinements();
839 }
840
841 public final void not() throws RecognitionException, TokenStreamException {
842
843
844 log.debug( "entered not()" );
845
846
847 match(ID_not);
848 {
849 _loop80:
850 do {
851 if ((LA(1)==SP)) {
852 match(SP);
853 }
854 else {
855 break _loop80;
856 }
857
858 } while (true);
859 }
860 match(COLON);
861 {
862 _loop82:
863 do {
864 if ((LA(1)==SP)) {
865 match(SP);
866 }
867 else {
868 break _loop82;
869 }
870
871 } while (true);
872 }
873 refinement();
874 }
875
876 public final void refinements() throws RecognitionException, TokenStreamException {
877
878
879 log.debug( "entered refinements()" );
880
881
882 match(OPEN_CURLY);
883 {
884 _loop85:
885 do {
886 if ((LA(1)==SP)) {
887 match(SP);
888 }
889 else {
890 break _loop85;
891 }
892
893 } while (true);
894 }
895 {
896 switch ( LA(1)) {
897 case ID_item:
898 case ID_and:
899 case ID_or:
900 case ID_not:
901 {
902 refinement();
903 {
904 _loop88:
905 do {
906 if ((LA(1)==SP)) {
907 match(SP);
908 }
909 else {
910 break _loop88;
911 }
912
913 } while (true);
914 }
915 {
916 _loop94:
917 do {
918 if ((LA(1)==SEP)) {
919 match(SEP);
920 {
921 _loop91:
922 do {
923 if ((LA(1)==SP)) {
924 match(SP);
925 }
926 else {
927 break _loop91;
928 }
929
930 } while (true);
931 }
932 refinement();
933 {
934 _loop93:
935 do {
936 if ((LA(1)==SP)) {
937 match(SP);
938 }
939 else {
940 break _loop93;
941 }
942
943 } while (true);
944 }
945 }
946 else {
947 break _loop94;
948 }
949
950 } while (true);
951 }
952 break;
953 }
954 case CLOSE_CURLY:
955 {
956 break;
957 }
958 default:
959 {
960 throw new NoViableAltException(LT(1), getFilename());
961 }
962 }
963 }
964 match(CLOSE_CURLY);
965 }
966
967
968 public static final String[] _tokenNames = {
969 "<0>",
970 "EOF",
971 "<2>",
972 "NULL_TREE_LOOKAHEAD",
973 "\"end\"",
974 "OPEN_CURLY",
975 "SP",
976 "SEP",
977 "CLOSE_CURLY",
978 "\"base\"",
979 "\"specificExclusions\"",
980 "\"chopBefore\"",
981 "COLON",
982 "\"chopAfter\"",
983 "\"minimum\"",
984 "\"maximum\"",
985 "\"specificationFilter\"",
986 "FILTER",
987 "SAFEUTF8STRING",
988 "INTEGER",
989 "DESCR",
990 "NUMERICOID",
991 "\"item\"",
992 "\"and\"",
993 "\"or\"",
994 "\"not\"",
995 "INTEGER_OR_NUMERICOID",
996 "DOT",
997 "DIGIT",
998 "LDIGIT",
999 "ALPHA",
1000 "SAFEUTF8CHAR",
1001 "FILTER_VALUE"
1002 };
1003
1004
1005 }