This project has retired. For details please refer to its
Attic page.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26 package org.apache.chemistry.opencmis.server.support.query;
27
28
29 import org.antlr.runtime.*;
30 import java.util.Stack;
31 import java.util.List;
32 import java.util.ArrayList;
33
34
35 import org.antlr.runtime.tree.*;
36
37
38
39
40
41 public class TextSearchParser extends Parser {
42 public static final String[] tokenNames = new String[] {
43 "<invalid>", "<EOR>", "<DOWN>", "<UP>", "TEXT_AND", "TEXT_OR", "TEXT_MINUS", "AND", "OR", "QUOTE", "BACKSL", "ESC", "WS", "TEXT_SEARCH_PHRASE_STRING", "TEXT_SEARCH_PHRASE_STRING_LIT", "TEXT_SEARCH_WORD_LIT"
44 };
45 public static final int EOF=-1;
46 public static final int TEXT_AND=4;
47 public static final int TEXT_OR=5;
48 public static final int TEXT_MINUS=6;
49 public static final int AND=7;
50 public static final int OR=8;
51 public static final int QUOTE=9;
52 public static final int BACKSL=10;
53 public static final int ESC=11;
54 public static final int WS=12;
55 public static final int TEXT_SEARCH_PHRASE_STRING=13;
56 public static final int TEXT_SEARCH_PHRASE_STRING_LIT=14;
57 public static final int TEXT_SEARCH_WORD_LIT=15;
58
59
60
61
62
63 public TextSearchParser(TokenStream input) {
64 this(input, new RecognizerSharedState());
65 }
66 public TextSearchParser(TokenStream input, RecognizerSharedState state) {
67 super(input, state);
68
69 }
70
71 protected TreeAdaptor adaptor = new CommonTreeAdaptor();
72
73 public void setTreeAdaptor(TreeAdaptor adaptor) {
74 this.adaptor = adaptor;
75 }
76 public TreeAdaptor getTreeAdaptor() {
77 return adaptor;
78 }
79
80 public String[] getTokenNames() { return TextSearchParser.tokenNames; }
81 public String getGrammarFileName() { return "org/apache/chemistry/opencmis/server/support/query/TextSearch.g"; }
82
83
84 public static class text_search_expression_return extends ParserRuleReturnScope {
85 CommonTree tree;
86 public Object getTree() { return tree; }
87 };
88
89
90
91 public final TextSearchParser.text_search_expression_return text_search_expression() throws RecognitionException {
92 TextSearchParser.text_search_expression_return retval = new TextSearchParser.text_search_expression_return();
93 retval.start = input.LT(1);
94
95 CommonTree root_0 = null;
96
97 Token OR2=null;
98 TextSearchParser.conjunct_return conjunct1 = null;
99
100 TextSearchParser.conjunct_return conjunct3 = null;
101
102 TextSearchParser.conjunct_return conjunct4 = null;
103
104
105 CommonTree OR2_tree=null;
106 RewriteRuleTokenStream stream_OR=new RewriteRuleTokenStream(adaptor,"token OR");
107 RewriteRuleSubtreeStream stream_conjunct=new RewriteRuleSubtreeStream(adaptor,"rule conjunct");
108 try {
109
110 int alt2=2;
111 alt2 = dfa2.predict(input);
112 switch (alt2) {
113 case 1 :
114
115 {
116 pushFollow(FOLLOW_conjunct_in_text_search_expression367);
117 conjunct1=conjunct();
118
119 state._fsp--;
120
121 stream_conjunct.add(conjunct1.getTree());
122
123 int cnt1=0;
124 loop1:
125 do {
126 int alt1=2;
127 switch ( input.LA(1) ) {
128 case OR:
129 {
130 alt1=1;
131 }
132 break;
133
134 }
135
136 switch (alt1) {
137 case 1 :
138
139 {
140 OR2=(Token)match(input,OR,FOLLOW_OR_in_text_search_expression370);
141 stream_OR.add(OR2);
142
143 pushFollow(FOLLOW_conjunct_in_text_search_expression372);
144 conjunct3=conjunct();
145
146 state._fsp--;
147
148 stream_conjunct.add(conjunct3.getTree());
149
150 }
151 break;
152
153 default :
154 if ( cnt1 >= 1 ) break loop1;
155 EarlyExitException eee =
156 new EarlyExitException(1, input);
157 throw eee;
158 }
159 cnt1++;
160 } while (true);
161
162
163
164
165
166
167
168
169
170
171 retval.tree = root_0;
172 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
173
174 root_0 = (CommonTree)adaptor.nil();
175
176 {
177
178 {
179 CommonTree root_1 = (CommonTree)adaptor.nil();
180 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(TEXT_OR, "TEXT_OR"), root_1);
181
182 if ( !(stream_conjunct.hasNext()) ) {
183 throw new RewriteEarlyExitException();
184 }
185 while ( stream_conjunct.hasNext() ) {
186 adaptor.addChild(root_1, stream_conjunct.nextTree());
187
188 }
189 stream_conjunct.reset();
190
191 adaptor.addChild(root_0, root_1);
192 }
193
194 }
195
196 retval.tree = root_0;
197 }
198 break;
199 case 2 :
200
201 {
202 root_0 = (CommonTree)adaptor.nil();
203
204 pushFollow(FOLLOW_conjunct_in_text_search_expression393);
205 conjunct4=conjunct();
206
207 state._fsp--;
208
209 adaptor.addChild(root_0, conjunct4.getTree());
210
211 }
212 break;
213
214 }
215 retval.stop = input.LT(-1);
216
217 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
218 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
219
220 }
221 catch (RecognitionException re) {
222 reportError(re);
223 recover(input,re);
224 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);
225
226 }
227 finally {
228 }
229 return retval;
230 }
231
232
233 public static class conjunct_return extends ParserRuleReturnScope {
234 CommonTree tree;
235 public Object getTree() { return tree; }
236 };
237
238
239
240 public final TextSearchParser.conjunct_return conjunct() throws RecognitionException {
241 TextSearchParser.conjunct_return retval = new TextSearchParser.conjunct_return();
242 retval.start = input.LT(1);
243
244 CommonTree root_0 = null;
245
246 Token AND6=null;
247 TextSearchParser.term_return term5 = null;
248
249 TextSearchParser.term_return term7 = null;
250
251 TextSearchParser.term_return term8 = null;
252
253
254 CommonTree AND6_tree=null;
255 RewriteRuleTokenStream stream_AND=new RewriteRuleTokenStream(adaptor,"token AND");
256 RewriteRuleSubtreeStream stream_term=new RewriteRuleSubtreeStream(adaptor,"rule term");
257 try {
258
259 int alt5=2;
260 switch ( input.LA(1) ) {
261 case TEXT_MINUS:
262 {
263 switch ( input.LA(2) ) {
264 case TEXT_SEARCH_WORD_LIT:
265 {
266 switch ( input.LA(3) ) {
267 case TEXT_MINUS:
268 case AND:
269 case TEXT_SEARCH_PHRASE_STRING_LIT:
270 case TEXT_SEARCH_WORD_LIT:
271 {
272 alt5=1;
273 }
274 break;
275 case EOF:
276 case OR:
277 {
278 alt5=2;
279 }
280 break;
281 default:
282 NoViableAltException nvae =
283 new NoViableAltException("", 5, 2, input);
284
285 throw nvae;
286 }
287
288 }
289 break;
290 case TEXT_SEARCH_PHRASE_STRING_LIT:
291 {
292 switch ( input.LA(3) ) {
293 case TEXT_MINUS:
294 case AND:
295 case TEXT_SEARCH_PHRASE_STRING_LIT:
296 case TEXT_SEARCH_WORD_LIT:
297 {
298 alt5=1;
299 }
300 break;
301 case EOF:
302 case OR:
303 {
304 alt5=2;
305 }
306 break;
307 default:
308 NoViableAltException nvae =
309 new NoViableAltException("", 5, 3, input);
310
311 throw nvae;
312 }
313
314 }
315 break;
316 default:
317 NoViableAltException nvae =
318 new NoViableAltException("", 5, 1, input);
319
320 throw nvae;
321 }
322
323 }
324 break;
325 case TEXT_SEARCH_WORD_LIT:
326 {
327 switch ( input.LA(2) ) {
328 case TEXT_MINUS:
329 case AND:
330 case TEXT_SEARCH_PHRASE_STRING_LIT:
331 case TEXT_SEARCH_WORD_LIT:
332 {
333 alt5=1;
334 }
335 break;
336 case EOF:
337 case OR:
338 {
339 alt5=2;
340 }
341 break;
342 default:
343 NoViableAltException nvae =
344 new NoViableAltException("", 5, 2, input);
345
346 throw nvae;
347 }
348
349 }
350 break;
351 case TEXT_SEARCH_PHRASE_STRING_LIT:
352 {
353 switch ( input.LA(2) ) {
354 case TEXT_MINUS:
355 case AND:
356 case TEXT_SEARCH_PHRASE_STRING_LIT:
357 case TEXT_SEARCH_WORD_LIT:
358 {
359 alt5=1;
360 }
361 break;
362 case EOF:
363 case OR:
364 {
365 alt5=2;
366 }
367 break;
368 default:
369 NoViableAltException nvae =
370 new NoViableAltException("", 5, 3, input);
371
372 throw nvae;
373 }
374
375 }
376 break;
377 default:
378 NoViableAltException nvae =
379 new NoViableAltException("", 5, 0, input);
380
381 throw nvae;
382 }
383
384 switch (alt5) {
385 case 1 :
386
387 {
388 pushFollow(FOLLOW_term_in_conjunct407);
389 term5=term();
390
391 state._fsp--;
392
393 stream_term.add(term5.getTree());
394
395 int cnt4=0;
396 loop4:
397 do {
398 int alt4=2;
399 switch ( input.LA(1) ) {
400 case TEXT_MINUS:
401 case AND:
402 case TEXT_SEARCH_PHRASE_STRING_LIT:
403 case TEXT_SEARCH_WORD_LIT:
404 {
405 alt4=1;
406 }
407 break;
408
409 }
410
411 switch (alt4) {
412 case 1 :
413
414 {
415
416 int alt3=2;
417 switch ( input.LA(1) ) {
418 case AND:
419 {
420 alt3=1;
421 }
422 break;
423 }
424
425 switch (alt3) {
426 case 1 :
427
428 {
429 AND6=(Token)match(input,AND,FOLLOW_AND_in_conjunct410);
430 stream_AND.add(AND6);
431
432
433 }
434 break;
435
436 }
437
438 pushFollow(FOLLOW_term_in_conjunct413);
439 term7=term();
440
441 state._fsp--;
442
443 stream_term.add(term7.getTree());
444
445 }
446 break;
447
448 default :
449 if ( cnt4 >= 1 ) break loop4;
450 EarlyExitException eee =
451 new EarlyExitException(4, input);
452 throw eee;
453 }
454 cnt4++;
455 } while (true);
456
457
458
459
460
461
462
463
464
465
466 retval.tree = root_0;
467 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
468
469 root_0 = (CommonTree)adaptor.nil();
470
471 {
472
473 {
474 CommonTree root_1 = (CommonTree)adaptor.nil();
475 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(TEXT_AND, "TEXT_AND"), root_1);
476
477 if ( !(stream_term.hasNext()) ) {
478 throw new RewriteEarlyExitException();
479 }
480 while ( stream_term.hasNext() ) {
481 adaptor.addChild(root_1, stream_term.nextTree());
482
483 }
484 stream_term.reset();
485
486 adaptor.addChild(root_0, root_1);
487 }
488
489 }
490
491 retval.tree = root_0;
492 }
493 break;
494 case 2 :
495
496 {
497 root_0 = (CommonTree)adaptor.nil();
498
499 pushFollow(FOLLOW_term_in_conjunct436);
500 term8=term();
501
502 state._fsp--;
503
504 adaptor.addChild(root_0, term8.getTree());
505
506 }
507 break;
508
509 }
510 retval.stop = input.LT(-1);
511
512 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
513 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
514
515 }
516 catch (RecognitionException re) {
517 reportError(re);
518 recover(input,re);
519 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);
520
521 }
522 finally {
523 }
524 return retval;
525 }
526
527
528 public static class term_return extends ParserRuleReturnScope {
529 CommonTree tree;
530 public Object getTree() { return tree; }
531 };
532
533
534
535 public final TextSearchParser.term_return term() throws RecognitionException {
536 TextSearchParser.term_return retval = new TextSearchParser.term_return();
537 retval.start = input.LT(1);
538
539 CommonTree root_0 = null;
540
541 Token TEXT_MINUS9=null;
542 TextSearchParser.word_return word10 = null;
543
544 TextSearchParser.phrase_return phrase11 = null;
545
546
547 CommonTree TEXT_MINUS9_tree=null;
548
549 try {
550
551
552 {
553 root_0 = (CommonTree)adaptor.nil();
554
555
556 int alt6=2;
557 switch ( input.LA(1) ) {
558 case TEXT_MINUS:
559 {
560 alt6=1;
561 }
562 break;
563 }
564
565 switch (alt6) {
566 case 1 :
567
568 {
569 TEXT_MINUS9=(Token)match(input,TEXT_MINUS,FOLLOW_TEXT_MINUS_in_term451);
570 TEXT_MINUS9_tree = (CommonTree)adaptor.create(TEXT_MINUS9);
571 root_0 = (CommonTree)adaptor.becomeRoot(TEXT_MINUS9_tree, root_0);
572
573
574 }
575 break;
576
577 }
578
579
580 int alt7=2;
581 switch ( input.LA(1) ) {
582 case TEXT_SEARCH_WORD_LIT:
583 {
584 alt7=1;
585 }
586 break;
587 case TEXT_SEARCH_PHRASE_STRING_LIT:
588 {
589 alt7=2;
590 }
591 break;
592 default:
593 NoViableAltException nvae =
594 new NoViableAltException("", 7, 0, input);
595
596 throw nvae;
597 }
598
599 switch (alt7) {
600 case 1 :
601
602 {
603 pushFollow(FOLLOW_word_in_term456);
604 word10=word();
605
606 state._fsp--;
607
608 adaptor.addChild(root_0, word10.getTree());
609
610 }
611 break;
612 case 2 :
613
614 {
615 pushFollow(FOLLOW_phrase_in_term460);
616 phrase11=phrase();
617
618 state._fsp--;
619
620 adaptor.addChild(root_0, phrase11.getTree());
621
622 }
623 break;
624
625 }
626
627
628 }
629
630 retval.stop = input.LT(-1);
631
632 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
633 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
634
635 }
636 catch (RecognitionException re) {
637 reportError(re);
638 recover(input,re);
639 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);
640
641 }
642 finally {
643 }
644 return retval;
645 }
646
647
648 public static class phrase_return extends ParserRuleReturnScope {
649 CommonTree tree;
650 public Object getTree() { return tree; }
651 };
652
653
654
655 public final TextSearchParser.phrase_return phrase() throws RecognitionException {
656 TextSearchParser.phrase_return retval = new TextSearchParser.phrase_return();
657 retval.start = input.LT(1);
658
659 CommonTree root_0 = null;
660
661 Token TEXT_SEARCH_PHRASE_STRING_LIT12=null;
662
663 CommonTree TEXT_SEARCH_PHRASE_STRING_LIT12_tree=null;
664
665 try {
666
667
668 {
669 root_0 = (CommonTree)adaptor.nil();
670
671 TEXT_SEARCH_PHRASE_STRING_LIT12=(Token)match(input,TEXT_SEARCH_PHRASE_STRING_LIT,FOLLOW_TEXT_SEARCH_PHRASE_STRING_LIT_in_phrase476);
672 TEXT_SEARCH_PHRASE_STRING_LIT12_tree = (CommonTree)adaptor.create(TEXT_SEARCH_PHRASE_STRING_LIT12);
673 adaptor.addChild(root_0, TEXT_SEARCH_PHRASE_STRING_LIT12_tree);
674
675
676 }
677
678 retval.stop = input.LT(-1);
679
680 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
681 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
682
683 }
684 catch (RecognitionException re) {
685 reportError(re);
686 recover(input,re);
687 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);
688
689 }
690 finally {
691 }
692 return retval;
693 }
694
695
696 public static class word_return extends ParserRuleReturnScope {
697 CommonTree tree;
698 public Object getTree() { return tree; }
699 };
700
701
702
703 public final TextSearchParser.word_return word() throws RecognitionException {
704 TextSearchParser.word_return retval = new TextSearchParser.word_return();
705 retval.start = input.LT(1);
706
707 CommonTree root_0 = null;
708
709 Token TEXT_SEARCH_WORD_LIT13=null;
710
711 CommonTree TEXT_SEARCH_WORD_LIT13_tree=null;
712
713 try {
714
715
716 {
717 root_0 = (CommonTree)adaptor.nil();
718
719 TEXT_SEARCH_WORD_LIT13=(Token)match(input,TEXT_SEARCH_WORD_LIT,FOLLOW_TEXT_SEARCH_WORD_LIT_in_word490);
720 TEXT_SEARCH_WORD_LIT13_tree = (CommonTree)adaptor.create(TEXT_SEARCH_WORD_LIT13);
721 adaptor.addChild(root_0, TEXT_SEARCH_WORD_LIT13_tree);
722
723
724 }
725
726 retval.stop = input.LT(-1);
727
728 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
729 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
730
731 }
732 catch (RecognitionException re) {
733 reportError(re);
734 recover(input,re);
735 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);
736
737 }
738 finally {
739 }
740 return retval;
741 }
742
743
744
745
746
747 protected DFA2 dfa2 = new DFA2(this);
748 static final String DFA2_eotS =
749 "\12\uffff";
750 static final String DFA2_eofS =
751 "\2\uffff\2\11\2\uffff\2\11\2\uffff";
752 static final String DFA2_minS =
753 "\1\6\1\16\3\6\1\16\2\6\2\uffff";
754 static final String DFA2_maxS =
755 "\10\17\2\uffff";
756 static final String DFA2_acceptS =
757 "\10\uffff\1\1\1\2";
758 static final String DFA2_specialS =
759 "\12\uffff}>";
760 static final String[] DFA2_transitionS = {
761 "\1\1\7\uffff\1\3\1\2",
762 "\1\3\1\2",
763 "\1\5\1\4\1\10\5\uffff\1\7\1\6",
764 "\1\5\1\4\1\10\5\uffff\1\7\1\6",
765 "\1\5\7\uffff\1\7\1\6",
766 "\1\7\1\6",
767 "\1\5\1\4\1\10\5\uffff\1\7\1\6",
768 "\1\5\1\4\1\10\5\uffff\1\7\1\6",
769 "",
770 ""
771 };
772
773 static final short[] DFA2_eot = DFA.unpackEncodedString(DFA2_eotS);
774 static final short[] DFA2_eof = DFA.unpackEncodedString(DFA2_eofS);
775 static final char[] DFA2_min = DFA.unpackEncodedStringToUnsignedChars(DFA2_minS);
776 static final char[] DFA2_max = DFA.unpackEncodedStringToUnsignedChars(DFA2_maxS);
777 static final short[] DFA2_accept = DFA.unpackEncodedString(DFA2_acceptS);
778 static final short[] DFA2_special = DFA.unpackEncodedString(DFA2_specialS);
779 static final short[][] DFA2_transition;
780
781 static {
782 int numStates = DFA2_transitionS.length;
783 DFA2_transition = new short[numStates][];
784 for (int i=0; i<numStates; i++) {
785 DFA2_transition[i] = DFA.unpackEncodedString(DFA2_transitionS[i]);
786 }
787 }
788
789 class DFA2 extends DFA {
790
791 public DFA2(BaseRecognizer recognizer) {
792 this.recognizer = recognizer;
793 this.decisionNumber = 2;
794 this.eot = DFA2_eot;
795 this.eof = DFA2_eof;
796 this.min = DFA2_min;
797 this.max = DFA2_max;
798 this.accept = DFA2_accept;
799 this.special = DFA2_special;
800 this.transition = DFA2_transition;
801 }
802 public String getDescription() {
803 return "150:1: text_search_expression : ( conjunct ( OR conjunct )+ -> ^( TEXT_OR ( conjunct )+ ) | conjunct );";
804 }
805 }
806
807
808 public static final BitSet FOLLOW_conjunct_in_text_search_expression367 = new BitSet(new long[]{0x0000000000000100L});
809 public static final BitSet FOLLOW_OR_in_text_search_expression370 = new BitSet(new long[]{0x000000000000C040L});
810 public static final BitSet FOLLOW_conjunct_in_text_search_expression372 = new BitSet(new long[]{0x0000000000000102L});
811 public static final BitSet FOLLOW_conjunct_in_text_search_expression393 = new BitSet(new long[]{0x0000000000000002L});
812 public static final BitSet FOLLOW_term_in_conjunct407 = new BitSet(new long[]{0x000000000000C0C0L});
813 public static final BitSet FOLLOW_AND_in_conjunct410 = new BitSet(new long[]{0x000000000000C040L});
814 public static final BitSet FOLLOW_term_in_conjunct413 = new BitSet(new long[]{0x000000000000C0C2L});
815 public static final BitSet FOLLOW_term_in_conjunct436 = new BitSet(new long[]{0x0000000000000002L});
816 public static final BitSet FOLLOW_TEXT_MINUS_in_term451 = new BitSet(new long[]{0x000000000000C040L});
817 public static final BitSet FOLLOW_word_in_term456 = new BitSet(new long[]{0x0000000000000002L});
818 public static final BitSet FOLLOW_phrase_in_term460 = new BitSet(new long[]{0x0000000000000002L});
819 public static final BitSet FOLLOW_TEXT_SEARCH_PHRASE_STRING_LIT_in_phrase476 = new BitSet(new long[]{0x0000000000000002L});
820 public static final BitSet FOLLOW_TEXT_SEARCH_WORD_LIT_in_word490 = new BitSet(new long[]{0x0000000000000002L});
821
822 }