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
27
28
29 package org.apache.chemistry.opencmis.server.support.query;
30
31
32 import org.antlr.runtime.*;
33 import java.util.Stack;
34 import java.util.List;
35 import java.util.ArrayList;
36
37
38 import org.antlr.runtime.tree.*;
39
40 public class CmisQlStrictParser_CmisBaseGrammar extends Parser {
41 public static final int EOF=-1;
42 public static final int TABLE=4;
43 public static final int COL=5;
44 public static final int SEL_LIST=6;
45 public static final int IN_LIST=7;
46 public static final int IN_ANY=8;
47 public static final int NOT_IN_ANY=9;
48 public static final int EQ_ANY=10;
49 public static final int NOT_IN=11;
50 public static final int NOT_LIKE=12;
51 public static final int IS_NULL=13;
52 public static final int IS_NOT_NULL=14;
53 public static final int ORDER_BY=15;
54 public static final int SELECT=16;
55 public static final int FROM=17;
56 public static final int AS=18;
57 public static final int JOIN=19;
58 public static final int INNER=20;
59 public static final int OUTER=21;
60 public static final int LEFT=22;
61 public static final int RIGHT=23;
62 public static final int ON=24;
63 public static final int WHERE=25;
64 public static final int ORDER=26;
65 public static final int BY=27;
66 public static final int ASC=28;
67 public static final int DESC=29;
68 public static final int IS=30;
69 public static final int NULL=31;
70 public static final int AND=32;
71 public static final int OR=33;
72 public static final int NOT=34;
73 public static final int IN=35;
74 public static final int LIKE=36;
75 public static final int ANY=37;
76 public static final int CONTAINS=38;
77 public static final int SCORE=39;
78 public static final int IN_FOLDER=40;
79 public static final int IN_TREE=41;
80 public static final int TIMESTAMP=42;
81 public static final int STAR=43;
82 public static final int LPAR=44;
83 public static final int RPAR=45;
84 public static final int COMMA=46;
85 public static final int DOT=47;
86 public static final int EQ=48;
87 public static final int NEQ=49;
88 public static final int LT=50;
89 public static final int GT=51;
90 public static final int LTEQ=52;
91 public static final int GTEQ=53;
92 public static final int BOOL_LIT=54;
93 public static final int Sign=55;
94 public static final int Digits=56;
95 public static final int ExactNumLit=57;
96 public static final int ApproxNumLit=58;
97 public static final int NUM_LIT=59;
98 public static final int QUOTE=60;
99 public static final int BACKSL=61;
100 public static final int UNDERSCORE=62;
101 public static final int PERCENT=63;
102 public static final int ESC=64;
103 public static final int STRING_LIT=65;
104 public static final int WS=66;
105 public static final int TIME_LIT=67;
106 public static final int ID=68;
107
108
109
110 public CmisQlStrictParser gCmisQlStrictParser;
111 public CmisQlStrictParser gParent;
112
113
114 public CmisQlStrictParser_CmisBaseGrammar(TokenStream input, CmisQlStrictParser gCmisQlStrictParser) {
115 this(input, new RecognizerSharedState(), gCmisQlStrictParser);
116 }
117 public CmisQlStrictParser_CmisBaseGrammar(TokenStream input, RecognizerSharedState state, CmisQlStrictParser gCmisQlStrictParser) {
118 super(input, state);
119 this.gCmisQlStrictParser = gCmisQlStrictParser;
120
121 gParent = gCmisQlStrictParser;
122 }
123
124 protected TreeAdaptor adaptor = new CommonTreeAdaptor();
125
126 public void setTreeAdaptor(TreeAdaptor adaptor) {
127 this.adaptor = adaptor;
128 }
129 public TreeAdaptor getTreeAdaptor() {
130 return adaptor;
131 }
132
133 public String[] getTokenNames() { return CmisQlStrictParser.tokenNames; }
134 public String getGrammarFileName() { return "CmisBaseGrammar.g"; }
135
136
137 private List<String> errorMessages = new ArrayList<String>();
138
139 public boolean hasErrors() {
140 return errorMessages.size() > 0;
141 }
142
143 public String getErrorMessages() {
144 StringBuffer allMessages = new StringBuffer();
145
146 for (String msg : errorMessages)
147 allMessages.append(msg).append('\n');
148
149 return allMessages.toString();
150 }
151
152 @Override
153
154 public void emitErrorMessage(String msg) {
155 errorMessages.add(msg);
156 }
157
158
159
160 public static class query_return extends ParserRuleReturnScope {
161 Object tree;
162 public Object getTree() { return tree; }
163 };
164
165
166
167 public final CmisQlStrictParser_CmisBaseGrammar.query_return query() throws RecognitionException {
168 CmisQlStrictParser_CmisBaseGrammar.query_return retval = new CmisQlStrictParser_CmisBaseGrammar.query_return();
169 retval.start = input.LT(1);
170
171 Object root_0 = null;
172
173 Token SELECT1=null;
174 CmisQlStrictParser_CmisBaseGrammar.select_list_return select_list2 = null;
175
176 CmisQlStrictParser_CmisBaseGrammar.from_clause_return from_clause3 = null;
177
178 CmisQlStrictParser_CmisBaseGrammar.where_clause_return where_clause4 = null;
179
180 CmisQlStrictParser_CmisBaseGrammar.order_by_clause_return order_by_clause5 = null;
181
182
183 Object SELECT1_tree=null;
184 RewriteRuleTokenStream stream_SELECT=new RewriteRuleTokenStream(adaptor,"token SELECT");
185 RewriteRuleSubtreeStream stream_select_list=new RewriteRuleSubtreeStream(adaptor,"rule select_list");
186 RewriteRuleSubtreeStream stream_from_clause=new RewriteRuleSubtreeStream(adaptor,"rule from_clause");
187 RewriteRuleSubtreeStream stream_order_by_clause=new RewriteRuleSubtreeStream(adaptor,"rule order_by_clause");
188 RewriteRuleSubtreeStream stream_where_clause=new RewriteRuleSubtreeStream(adaptor,"rule where_clause");
189 try {
190
191
192 {
193 SELECT1=(Token)match(input,SELECT,FOLLOW_SELECT_in_query57);
194 stream_SELECT.add(SELECT1);
195
196 pushFollow(FOLLOW_select_list_in_query59);
197 select_list2=select_list();
198
199 state._fsp--;
200
201 stream_select_list.add(select_list2.getTree());
202 pushFollow(FOLLOW_from_clause_in_query61);
203 from_clause3=from_clause();
204
205 state._fsp--;
206
207 stream_from_clause.add(from_clause3.getTree());
208
209 int alt1=2;
210 switch ( input.LA(1) ) {
211 case WHERE:
212 {
213 alt1=1;
214 }
215 break;
216 }
217
218 switch (alt1) {
219 case 1 :
220
221 {
222 pushFollow(FOLLOW_where_clause_in_query63);
223 where_clause4=where_clause();
224
225 state._fsp--;
226
227 stream_where_clause.add(where_clause4.getTree());
228
229 }
230 break;
231
232 }
233
234
235 int alt2=2;
236 switch ( input.LA(1) ) {
237 case ORDER:
238 {
239 alt2=1;
240 }
241 break;
242 }
243
244 switch (alt2) {
245 case 1 :
246
247 {
248 pushFollow(FOLLOW_order_by_clause_in_query66);
249 order_by_clause5=order_by_clause();
250
251 state._fsp--;
252
253 stream_order_by_clause.add(order_by_clause5.getTree());
254
255 }
256 break;
257
258 }
259
260
261
262
263
264
265
266
267
268
269 retval.tree = root_0;
270 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
271
272 root_0 = (Object)adaptor.nil();
273
274 {
275
276 {
277 Object root_1 = (Object)adaptor.nil();
278 root_1 = (Object)adaptor.becomeRoot(stream_SELECT.nextNode(), root_1);
279
280 adaptor.addChild(root_1, stream_select_list.nextTree());
281 adaptor.addChild(root_1, stream_from_clause.nextTree());
282
283 if ( stream_order_by_clause.hasNext() ) {
284 adaptor.addChild(root_1, stream_order_by_clause.nextTree());
285
286 }
287 stream_order_by_clause.reset();
288
289 if ( stream_where_clause.hasNext() ) {
290 adaptor.addChild(root_1, stream_where_clause.nextTree());
291
292 }
293 stream_where_clause.reset();
294
295 adaptor.addChild(root_0, root_1);
296 }
297
298 }
299
300 retval.tree = root_0;
301 }
302
303 retval.stop = input.LT(-1);
304
305 retval.tree = (Object)adaptor.rulePostProcessing(root_0);
306 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
307
308 }
309 catch (RecognitionException re) {
310 reportError(re);
311 recover(input,re);
312 retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
313
314 }
315 finally {
316 }
317 return retval;
318 }
319
320
321 public static class select_list_return extends ParserRuleReturnScope {
322 Object tree;
323 public Object getTree() { return tree; }
324 };
325
326
327
328 public final CmisQlStrictParser_CmisBaseGrammar.select_list_return select_list() throws RecognitionException {
329 CmisQlStrictParser_CmisBaseGrammar.select_list_return retval = new CmisQlStrictParser_CmisBaseGrammar.select_list_return();
330 retval.start = input.LT(1);
331
332 Object root_0 = null;
333
334 Token STAR6=null;
335 Token COMMA8=null;
336 CmisQlStrictParser_CmisBaseGrammar.select_sublist_return select_sublist7 = null;
337
338 CmisQlStrictParser_CmisBaseGrammar.select_sublist_return select_sublist9 = null;
339
340
341 Object STAR6_tree=null;
342 Object COMMA8_tree=null;
343 RewriteRuleTokenStream stream_COMMA=new RewriteRuleTokenStream(adaptor,"token COMMA");
344 RewriteRuleSubtreeStream stream_select_sublist=new RewriteRuleSubtreeStream(adaptor,"rule select_sublist");
345 try {
346
347 int alt4=2;
348 switch ( input.LA(1) ) {
349 case STAR:
350 {
351 alt4=1;
352 }
353 break;
354 case SCORE:
355 case ID:
356 {
357 alt4=2;
358 }
359 break;
360 default:
361 NoViableAltException nvae =
362 new NoViableAltException("", 4, 0, input);
363
364 throw nvae;
365 }
366
367 switch (alt4) {
368 case 1 :
369
370 {
371 root_0 = (Object)adaptor.nil();
372
373 STAR6=(Token)match(input,STAR,FOLLOW_STAR_in_select_list99);
374 STAR6_tree = (Object)adaptor.create(STAR6);
375 adaptor.addChild(root_0, STAR6_tree);
376
377
378 }
379 break;
380 case 2 :
381
382 {
383 pushFollow(FOLLOW_select_sublist_in_select_list107);
384 select_sublist7=select_sublist();
385
386 state._fsp--;
387
388 stream_select_sublist.add(select_sublist7.getTree());
389
390 loop3:
391 do {
392 int alt3=2;
393 switch ( input.LA(1) ) {
394 case COMMA:
395 {
396 alt3=1;
397 }
398 break;
399
400 }
401
402 switch (alt3) {
403 case 1 :
404
405 {
406 COMMA8=(Token)match(input,COMMA,FOLLOW_COMMA_in_select_list111);
407 stream_COMMA.add(COMMA8);
408
409 pushFollow(FOLLOW_select_sublist_in_select_list113);
410 select_sublist9=select_sublist();
411
412 state._fsp--;
413
414 stream_select_sublist.add(select_sublist9.getTree());
415
416 }
417 break;
418
419 default :
420 break loop3;
421 }
422 } while (true);
423
424
425
426
427
428
429
430
431
432
433 retval.tree = root_0;
434 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
435
436 root_0 = (Object)adaptor.nil();
437
438 {
439
440 {
441 Object root_1 = (Object)adaptor.nil();
442 root_1 = (Object)adaptor.becomeRoot((Object)adaptor.create(SEL_LIST, "SEL_LIST"), root_1);
443
444 if ( !(stream_select_sublist.hasNext()) ) {
445 throw new RewriteEarlyExitException();
446 }
447 while ( stream_select_sublist.hasNext() ) {
448 adaptor.addChild(root_1, stream_select_sublist.nextTree());
449
450 }
451 stream_select_sublist.reset();
452
453 adaptor.addChild(root_0, root_1);
454 }
455
456 }
457
458 retval.tree = root_0;
459 }
460 break;
461
462 }
463 retval.stop = input.LT(-1);
464
465 retval.tree = (Object)adaptor.rulePostProcessing(root_0);
466 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
467
468 }
469 catch (RecognitionException re) {
470 reportError(re);
471 recover(input,re);
472 retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
473
474 }
475 finally {
476 }
477 return retval;
478 }
479
480
481 public static class select_sublist_return extends ParserRuleReturnScope {
482 Object tree;
483 public Object getTree() { return tree; }
484 };
485
486
487
488 public final CmisQlStrictParser_CmisBaseGrammar.select_sublist_return select_sublist() throws RecognitionException {
489 CmisQlStrictParser_CmisBaseGrammar.select_sublist_return retval = new CmisQlStrictParser_CmisBaseGrammar.select_sublist_return();
490 retval.start = input.LT(1);
491
492 Object root_0 = null;
493
494 Token AS11=null;
495 Token DOT14=null;
496 Token STAR15=null;
497 CmisQlStrictParser_CmisBaseGrammar.value_expression_return value_expression10 = null;
498
499 CmisQlStrictParser_CmisBaseGrammar.column_name_return column_name12 = null;
500
501 CmisQlStrictParser_CmisBaseGrammar.qualifier_return qualifier13 = null;
502
503
504 Object AS11_tree=null;
505 Object DOT14_tree=null;
506 Object STAR15_tree=null;
507
508 try {
509
510 int alt7=2;
511 switch ( input.LA(1) ) {
512 case ID:
513 {
514 switch ( input.LA(2) ) {
515 case DOT:
516 {
517 switch ( input.LA(3) ) {
518 case STAR:
519 {
520 alt7=2;
521 }
522 break;
523 case ID:
524 {
525 alt7=1;
526 }
527 break;
528 default:
529 NoViableAltException nvae =
530 new NoViableAltException("", 7, 3, input);
531
532 throw nvae;
533 }
534
535 }
536 break;
537 case FROM:
538 case AS:
539 case COMMA:
540 case ID:
541 {
542 alt7=1;
543 }
544 break;
545 default:
546 NoViableAltException nvae =
547 new NoViableAltException("", 7, 1, input);
548
549 throw nvae;
550 }
551
552 }
553 break;
554 case SCORE:
555 {
556 alt7=1;
557 }
558 break;
559 default:
560 NoViableAltException nvae =
561 new NoViableAltException("", 7, 0, input);
562
563 throw nvae;
564 }
565
566 switch (alt7) {
567 case 1 :
568
569 {
570 root_0 = (Object)adaptor.nil();
571
572 pushFollow(FOLLOW_value_expression_in_select_sublist148);
573 value_expression10=value_expression();
574
575 state._fsp--;
576
577 adaptor.addChild(root_0, value_expression10.getTree());
578
579 int alt6=2;
580 switch ( input.LA(1) ) {
581 case AS:
582 case ID:
583 {
584 alt6=1;
585 }
586 break;
587 }
588
589 switch (alt6) {
590 case 1 :
591
592 {
593
594 int alt5=2;
595 switch ( input.LA(1) ) {
596 case AS:
597 {
598 alt5=1;
599 }
600 break;
601 }
602
603 switch (alt5) {
604 case 1 :
605
606 {
607 AS11=(Token)match(input,AS,FOLLOW_AS_in_select_sublist152);
608
609 }
610 break;
611
612 }
613
614 pushFollow(FOLLOW_column_name_in_select_sublist156);
615 column_name12=column_name();
616
617 state._fsp--;
618
619 adaptor.addChild(root_0, column_name12.getTree());
620
621 }
622 break;
623
624 }
625
626
627 }
628 break;
629 case 2 :
630
631 {
632 root_0 = (Object)adaptor.nil();
633
634 pushFollow(FOLLOW_qualifier_in_select_sublist167);
635 qualifier13=qualifier();
636
637 state._fsp--;
638
639 adaptor.addChild(root_0, qualifier13.getTree());
640 DOT14=(Token)match(input,DOT,FOLLOW_DOT_in_select_sublist169);
641 DOT14_tree = (Object)adaptor.create(DOT14);
642 adaptor.addChild(root_0, DOT14_tree);
643
644 STAR15=(Token)match(input,STAR,FOLLOW_STAR_in_select_sublist171);
645 STAR15_tree = (Object)adaptor.create(STAR15);
646 adaptor.addChild(root_0, STAR15_tree);
647
648
649 }
650 break;
651
652 }
653 retval.stop = input.LT(-1);
654
655 retval.tree = (Object)adaptor.rulePostProcessing(root_0);
656 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
657
658 }
659 catch (RecognitionException re) {
660 reportError(re);
661 recover(input,re);
662 retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
663
664 }
665 finally {
666 }
667 return retval;
668 }
669
670
671 public static class value_expression_return extends ParserRuleReturnScope {
672 Object tree;
673 public Object getTree() { return tree; }
674 };
675
676
677
678 public final CmisQlStrictParser_CmisBaseGrammar.value_expression_return value_expression() throws RecognitionException {
679 CmisQlStrictParser_CmisBaseGrammar.value_expression_return retval = new CmisQlStrictParser_CmisBaseGrammar.value_expression_return();
680 retval.start = input.LT(1);
681
682 Object root_0 = null;
683
684 CmisQlStrictParser_CmisBaseGrammar.column_reference_return column_reference16 = null;
685
686 CmisQlStrictParser_CmisBaseGrammar.numeric_value_function_return numeric_value_function17 = null;
687
688
689
690 try {
691
692 int alt8=2;
693 switch ( input.LA(1) ) {
694 case ID:
695 {
696 alt8=1;
697 }
698 break;
699 case SCORE:
700 {
701 alt8=2;
702 }
703 break;
704 default:
705 NoViableAltException nvae =
706 new NoViableAltException("", 8, 0, input);
707
708 throw nvae;
709 }
710
711 switch (alt8) {
712 case 1 :
713
714 {
715 root_0 = (Object)adaptor.nil();
716
717 pushFollow(FOLLOW_column_reference_in_value_expression194);
718 column_reference16=column_reference();
719
720 state._fsp--;
721
722 adaptor.addChild(root_0, column_reference16.getTree());
723
724 }
725 break;
726 case 2 :
727
728 {
729 root_0 = (Object)adaptor.nil();
730
731 pushFollow(FOLLOW_numeric_value_function_in_value_expression202);
732 numeric_value_function17=numeric_value_function();
733
734 state._fsp--;
735
736 adaptor.addChild(root_0, numeric_value_function17.getTree());
737
738 }
739 break;
740
741 }
742 retval.stop = input.LT(-1);
743
744 retval.tree = (Object)adaptor.rulePostProcessing(root_0);
745 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
746
747 }
748 catch (RecognitionException re) {
749 reportError(re);
750 recover(input,re);
751 retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
752
753 }
754 finally {
755 }
756 return retval;
757 }
758
759
760 public static class column_reference_return extends ParserRuleReturnScope {
761 Object tree;
762 public Object getTree() { return tree; }
763 };
764
765
766
767 public final CmisQlStrictParser_CmisBaseGrammar.column_reference_return column_reference() throws RecognitionException {
768 CmisQlStrictParser_CmisBaseGrammar.column_reference_return retval = new CmisQlStrictParser_CmisBaseGrammar.column_reference_return();
769 retval.start = input.LT(1);
770
771 Object root_0 = null;
772
773 Token DOT19=null;
774 CmisQlStrictParser_CmisBaseGrammar.qualifier_return qualifier18 = null;
775
776 CmisQlStrictParser_CmisBaseGrammar.column_name_return column_name20 = null;
777
778
779 Object DOT19_tree=null;
780 RewriteRuleTokenStream stream_DOT=new RewriteRuleTokenStream(adaptor,"token DOT");
781 RewriteRuleSubtreeStream stream_qualifier=new RewriteRuleSubtreeStream(adaptor,"rule qualifier");
782 RewriteRuleSubtreeStream stream_column_name=new RewriteRuleSubtreeStream(adaptor,"rule column_name");
783 try {
784
785
786 {
787
788 int alt9=2;
789 switch ( input.LA(1) ) {
790 case ID:
791 {
792 switch ( input.LA(2) ) {
793 case DOT:
794 {
795 alt9=1;
796 }
797 break;
798 }
799
800 }
801 break;
802 }
803
804 switch (alt9) {
805 case 1 :
806
807 {
808 pushFollow(FOLLOW_qualifier_in_column_reference220);
809 qualifier18=qualifier();
810
811 state._fsp--;
812
813 stream_qualifier.add(qualifier18.getTree());
814 DOT19=(Token)match(input,DOT,FOLLOW_DOT_in_column_reference222);
815 stream_DOT.add(DOT19);
816
817
818 }
819 break;
820
821 }
822
823 pushFollow(FOLLOW_column_name_in_column_reference227);
824 column_name20=column_name();
825
826 state._fsp--;
827
828 stream_column_name.add(column_name20.getTree());
829
830
831
832
833
834
835
836
837
838 retval.tree = root_0;
839 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
840
841 root_0 = (Object)adaptor.nil();
842
843 {
844
845 {
846 Object root_1 = (Object)adaptor.nil();
847 root_1 = (Object)adaptor.becomeRoot((Object)adaptor.create(COL, "COL"), root_1);
848
849
850 if ( stream_qualifier.hasNext() ) {
851 adaptor.addChild(root_1, stream_qualifier.nextTree());
852
853 }
854 stream_qualifier.reset();
855 adaptor.addChild(root_1, stream_column_name.nextTree());
856
857 adaptor.addChild(root_0, root_1);
858 }
859
860 }
861
862 retval.tree = root_0;
863 }
864
865 retval.stop = input.LT(-1);
866
867 retval.tree = (Object)adaptor.rulePostProcessing(root_0);
868 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
869
870 }
871 catch (RecognitionException re) {
872 reportError(re);
873 recover(input,re);
874 retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
875
876 }
877 finally {
878 }
879 return retval;
880 }
881
882
883 public static class multi_valued_column_reference_return extends ParserRuleReturnScope {
884 Object tree;
885 public Object getTree() { return tree; }
886 };
887
888
889
890 public final CmisQlStrictParser_CmisBaseGrammar.multi_valued_column_reference_return multi_valued_column_reference() throws RecognitionException {
891 CmisQlStrictParser_CmisBaseGrammar.multi_valued_column_reference_return retval = new CmisQlStrictParser_CmisBaseGrammar.multi_valued_column_reference_return();
892 retval.start = input.LT(1);
893
894 Object root_0 = null;
895
896 Token DOT22=null;
897 CmisQlStrictParser_CmisBaseGrammar.qualifier_return qualifier21 = null;
898
899 CmisQlStrictParser_CmisBaseGrammar.multi_valued_column_name_return multi_valued_column_name23 = null;
900
901
902 Object DOT22_tree=null;
903 RewriteRuleTokenStream stream_DOT=new RewriteRuleTokenStream(adaptor,"token DOT");
904 RewriteRuleSubtreeStream stream_multi_valued_column_name=new RewriteRuleSubtreeStream(adaptor,"rule multi_valued_column_name");
905 RewriteRuleSubtreeStream stream_qualifier=new RewriteRuleSubtreeStream(adaptor,"rule qualifier");
906 try {
907
908
909 {
910
911 int alt10=2;
912 switch ( input.LA(1) ) {
913 case ID:
914 {
915 switch ( input.LA(2) ) {
916 case DOT:
917 {
918 alt10=1;
919 }
920 break;
921 }
922
923 }
924 break;
925 }
926
927 switch (alt10) {
928 case 1 :
929
930 {
931 pushFollow(FOLLOW_qualifier_in_multi_valued_column_reference262);
932 qualifier21=qualifier();
933
934 state._fsp--;
935
936 stream_qualifier.add(qualifier21.getTree());
937 DOT22=(Token)match(input,DOT,FOLLOW_DOT_in_multi_valued_column_reference264);
938 stream_DOT.add(DOT22);
939
940
941 }
942 break;
943
944 }
945
946 pushFollow(FOLLOW_multi_valued_column_name_in_multi_valued_column_reference269);
947 multi_valued_column_name23=multi_valued_column_name();
948
949 state._fsp--;
950
951 stream_multi_valued_column_name.add(multi_valued_column_name23.getTree());
952
953
954
955
956
957
958
959
960
961 retval.tree = root_0;
962 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
963
964 root_0 = (Object)adaptor.nil();
965
966 {
967
968 {
969 Object root_1 = (Object)adaptor.nil();
970 root_1 = (Object)adaptor.becomeRoot((Object)adaptor.create(COL, "COL"), root_1);
971
972
973 if ( stream_qualifier.hasNext() ) {
974 adaptor.addChild(root_1, stream_qualifier.nextTree());
975
976 }
977 stream_qualifier.reset();
978 adaptor.addChild(root_1, stream_multi_valued_column_name.nextTree());
979
980 adaptor.addChild(root_0, root_1);
981 }
982
983 }
984
985 retval.tree = root_0;
986 }
987
988 retval.stop = input.LT(-1);
989
990 retval.tree = (Object)adaptor.rulePostProcessing(root_0);
991 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
992
993 }
994 catch (RecognitionException re) {
995 reportError(re);
996 recover(input,re);
997 retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
998
999 }
1000 finally {
1001 }
1002 return retval;
1003 }
1004
1005
1006 public static class numeric_value_function_return extends ParserRuleReturnScope {
1007 Object tree;
1008 public Object getTree() { return tree; }
1009 };
1010
1011
1012
1013 public final CmisQlStrictParser_CmisBaseGrammar.numeric_value_function_return numeric_value_function() throws RecognitionException {
1014 CmisQlStrictParser_CmisBaseGrammar.numeric_value_function_return retval = new CmisQlStrictParser_CmisBaseGrammar.numeric_value_function_return();
1015 retval.start = input.LT(1);
1016
1017 Object root_0 = null;
1018
1019 Token SCORE24=null;
1020 Token LPAR25=null;
1021 Token RPAR26=null;
1022
1023 Object SCORE24_tree=null;
1024 Object LPAR25_tree=null;
1025 Object RPAR26_tree=null;
1026 RewriteRuleTokenStream stream_RPAR=new RewriteRuleTokenStream(adaptor,"token RPAR");
1027 RewriteRuleTokenStream stream_SCORE=new RewriteRuleTokenStream(adaptor,"token SCORE");
1028 RewriteRuleTokenStream stream_LPAR=new RewriteRuleTokenStream(adaptor,"token LPAR");
1029
1030 try {
1031
1032
1033 {
1034 SCORE24=(Token)match(input,SCORE,FOLLOW_SCORE_in_numeric_value_function302);
1035 stream_SCORE.add(SCORE24);
1036
1037 LPAR25=(Token)match(input,LPAR,FOLLOW_LPAR_in_numeric_value_function304);
1038 stream_LPAR.add(LPAR25);
1039
1040 RPAR26=(Token)match(input,RPAR,FOLLOW_RPAR_in_numeric_value_function306);
1041 stream_RPAR.add(RPAR26);
1042
1043
1044
1045
1046
1047
1048
1049
1050
1051
1052 retval.tree = root_0;
1053 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
1054
1055 root_0 = (Object)adaptor.nil();
1056
1057 {
1058
1059 {
1060 Object root_1 = (Object)adaptor.nil();
1061 root_1 = (Object)adaptor.becomeRoot(stream_SCORE.nextNode(), root_1);
1062
1063 adaptor.addChild(root_0, root_1);
1064 }
1065
1066 }
1067
1068 retval.tree = root_0;
1069 }
1070
1071 retval.stop = input.LT(-1);
1072
1073 retval.tree = (Object)adaptor.rulePostProcessing(root_0);
1074 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
1075
1076 }
1077 catch (RecognitionException re) {
1078 reportError(re);
1079 recover(input,re);
1080 retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
1081
1082 }
1083 finally {
1084 }
1085 return retval;
1086 }
1087
1088
1089 public static class qualifier_return extends ParserRuleReturnScope {
1090 Object tree;
1091 public Object getTree() { return tree; }
1092 };
1093
1094
1095
1096 public final CmisQlStrictParser_CmisBaseGrammar.qualifier_return qualifier() throws RecognitionException {
1097 CmisQlStrictParser_CmisBaseGrammar.qualifier_return retval = new CmisQlStrictParser_CmisBaseGrammar.qualifier_return();
1098 retval.start = input.LT(1);
1099
1100 Object root_0 = null;
1101
1102 CmisQlStrictParser_CmisBaseGrammar.table_name_return table_name27 = null;
1103
1104
1105
1106 try {
1107
1108
1109 {
1110 root_0 = (Object)adaptor.nil();
1111
1112 pushFollow(FOLLOW_table_name_in_qualifier325);
1113 table_name27=table_name();
1114
1115 state._fsp--;
1116
1117 adaptor.addChild(root_0, table_name27.getTree());
1118
1119 }
1120
1121 retval.stop = input.LT(-1);
1122
1123 retval.tree = (Object)adaptor.rulePostProcessing(root_0);
1124 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
1125
1126 }
1127 catch (RecognitionException re) {
1128 reportError(re);
1129 recover(input,re);
1130 retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
1131
1132 }
1133 finally {
1134 }
1135 return retval;
1136 }
1137
1138
1139 public static class from_clause_return extends ParserRuleReturnScope {
1140 Object tree;
1141 public Object getTree() { return tree; }
1142 };
1143
1144
1145
1146 public final CmisQlStrictParser_CmisBaseGrammar.from_clause_return from_clause() throws RecognitionException {
1147 CmisQlStrictParser_CmisBaseGrammar.from_clause_return retval = new CmisQlStrictParser_CmisBaseGrammar.from_clause_return();
1148 retval.start = input.LT(1);
1149
1150 Object root_0 = null;
1151
1152 Token FROM28=null;
1153 CmisQlStrictParser_CmisBaseGrammar.table_reference_return table_reference29 = null;
1154
1155
1156 Object FROM28_tree=null;
1157
1158 try {
1159
1160
1161 {
1162 root_0 = (Object)adaptor.nil();
1163
1164 FROM28=(Token)match(input,FROM,FOLLOW_FROM_in_from_clause342);
1165 FROM28_tree = (Object)adaptor.create(FROM28);
1166 root_0 = (Object)adaptor.becomeRoot(FROM28_tree, root_0);
1167
1168 pushFollow(FOLLOW_table_reference_in_from_clause345);
1169 table_reference29=table_reference();
1170
1171 state._fsp--;
1172
1173 adaptor.addChild(root_0, table_reference29.getTree());
1174
1175 }
1176
1177 retval.stop = input.LT(-1);
1178
1179 retval.tree = (Object)adaptor.rulePostProcessing(root_0);
1180 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
1181
1182 }
1183 catch (RecognitionException re) {
1184 reportError(re);
1185 recover(input,re);
1186 retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
1187
1188 }
1189 finally {
1190 }
1191 return retval;
1192 }
1193
1194
1195 public static class table_reference_return extends ParserRuleReturnScope {
1196 Object tree;
1197 public Object getTree() { return tree; }
1198 };
1199
1200
1201
1202 public final CmisQlStrictParser_CmisBaseGrammar.table_reference_return table_reference() throws RecognitionException {
1203 CmisQlStrictParser_CmisBaseGrammar.table_reference_return retval = new CmisQlStrictParser_CmisBaseGrammar.table_reference_return();
1204 retval.start = input.LT(1);
1205
1206 Object root_0 = null;
1207
1208 CmisQlStrictParser_CmisBaseGrammar.one_table_return one_table30 = null;
1209
1210 CmisQlStrictParser_CmisBaseGrammar.table_join_return table_join31 = null;
1211
1212
1213
1214 try {
1215
1216
1217 {
1218 root_0 = (Object)adaptor.nil();
1219
1220 pushFollow(FOLLOW_one_table_in_table_reference356);
1221 one_table30=one_table();
1222
1223 state._fsp--;
1224
1225 adaptor.addChild(root_0, one_table30.getTree());
1226
1227 loop11:
1228 do {
1229 int alt11=2;
1230 switch ( input.LA(1) ) {
1231 case JOIN:
1232 case INNER:
1233 case LEFT:
1234 case RIGHT:
1235 {
1236 alt11=1;
1237 }
1238 break;
1239
1240 }
1241
1242 switch (alt11) {
1243 case 1 :
1244
1245 {
1246 pushFollow(FOLLOW_table_join_in_table_reference358);
1247 table_join31=table_join();
1248
1249 state._fsp--;
1250
1251 adaptor.addChild(root_0, table_join31.getTree());
1252
1253 }
1254 break;
1255
1256 default :
1257 break loop11;
1258 }
1259 } while (true);
1260
1261
1262 }
1263
1264 retval.stop = input.LT(-1);
1265
1266 retval.tree = (Object)adaptor.rulePostProcessing(root_0);
1267 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
1268
1269 }
1270 catch (RecognitionException re) {
1271 reportError(re);
1272 recover(input,re);
1273 retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
1274
1275 }
1276 finally {
1277 }
1278 return retval;
1279 }
1280
1281
1282 public static class table_join_return extends ParserRuleReturnScope {
1283 Object tree;
1284 public Object getTree() { return tree; }
1285 };
1286
1287
1288
1289 public final CmisQlStrictParser_CmisBaseGrammar.table_join_return table_join() throws RecognitionException {
1290 CmisQlStrictParser_CmisBaseGrammar.table_join_return retval = new CmisQlStrictParser_CmisBaseGrammar.table_join_return();
1291 retval.start = input.LT(1);
1292
1293 Object root_0 = null;
1294
1295 CmisQlStrictParser_CmisBaseGrammar.join_kind_return join_kind32 = null;
1296
1297 CmisQlStrictParser_CmisBaseGrammar.one_table_return one_table33 = null;
1298
1299 CmisQlStrictParser_CmisBaseGrammar.join_specification_return join_specification34 = null;
1300
1301
1302 RewriteRuleSubtreeStream stream_join_kind=new RewriteRuleSubtreeStream(adaptor,"rule join_kind");
1303 RewriteRuleSubtreeStream stream_join_specification=new RewriteRuleSubtreeStream(adaptor,"rule join_specification");
1304 RewriteRuleSubtreeStream stream_one_table=new RewriteRuleSubtreeStream(adaptor,"rule one_table");
1305 try {
1306
1307
1308 {
1309 pushFollow(FOLLOW_join_kind_in_table_join375);
1310 join_kind32=join_kind();
1311
1312 state._fsp--;
1313
1314 stream_join_kind.add(join_kind32.getTree());
1315 pushFollow(FOLLOW_one_table_in_table_join377);
1316 one_table33=one_table();
1317
1318 state._fsp--;
1319
1320 stream_one_table.add(one_table33.getTree());
1321
1322 int alt12=2;
1323 switch ( input.LA(1) ) {
1324 case ON:
1325 {
1326 alt12=1;
1327 }
1328 break;
1329 }
1330
1331 switch (alt12) {
1332 case 1 :
1333
1334 {
1335 pushFollow(FOLLOW_join_specification_in_table_join379);
1336 join_specification34=join_specification();
1337
1338 state._fsp--;
1339
1340 stream_join_specification.add(join_specification34.getTree());
1341
1342 }
1343 break;
1344
1345 }
1346
1347
1348
1349
1350
1351
1352
1353
1354
1355
1356 retval.tree = root_0;
1357 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
1358
1359 root_0 = (Object)adaptor.nil();
1360
1361 {
1362
1363 {
1364 Object root_1 = (Object)adaptor.nil();
1365 root_1 = (Object)adaptor.becomeRoot((Object)adaptor.create(JOIN, "JOIN"), root_1);
1366
1367 adaptor.addChild(root_1, stream_join_kind.nextTree());
1368 adaptor.addChild(root_1, stream_one_table.nextTree());
1369
1370 if ( stream_join_specification.hasNext() ) {
1371 adaptor.addChild(root_1, stream_join_specification.nextTree());
1372
1373 }
1374 stream_join_specification.reset();
1375
1376 adaptor.addChild(root_0, root_1);
1377 }
1378
1379 }
1380
1381 retval.tree = root_0;
1382 }
1383
1384 retval.stop = input.LT(-1);
1385
1386 retval.tree = (Object)adaptor.rulePostProcessing(root_0);
1387 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
1388
1389 }
1390 catch (RecognitionException re) {
1391 reportError(re);
1392 recover(input,re);
1393 retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
1394
1395 }
1396 finally {
1397 }
1398 return retval;
1399 }
1400
1401
1402 public static class one_table_return extends ParserRuleReturnScope {
1403 Object tree;
1404 public Object getTree() { return tree; }
1405 };
1406
1407
1408
1409 public final CmisQlStrictParser_CmisBaseGrammar.one_table_return one_table() throws RecognitionException {
1410 CmisQlStrictParser_CmisBaseGrammar.one_table_return retval = new CmisQlStrictParser_CmisBaseGrammar.one_table_return();
1411 retval.start = input.LT(1);
1412
1413 Object root_0 = null;
1414
1415 Token LPAR35=null;
1416 Token RPAR37=null;
1417 Token AS40=null;
1418 CmisQlStrictParser_CmisBaseGrammar.table_reference_return table_reference36 = null;
1419
1420 CmisQlStrictParser_CmisBaseGrammar.table_name_return table_name38 = null;
1421
1422 CmisQlStrictParser_CmisBaseGrammar.table_name_return table_name39 = null;
1423
1424 CmisQlStrictParser_CmisBaseGrammar.correlation_name_return correlation_name41 = null;
1425
1426
1427 Object LPAR35_tree=null;
1428 Object RPAR37_tree=null;
1429 Object AS40_tree=null;
1430 RewriteRuleTokenStream stream_AS=new RewriteRuleTokenStream(adaptor,"token AS");
1431 RewriteRuleSubtreeStream stream_table_name=new RewriteRuleSubtreeStream(adaptor,"rule table_name");
1432 RewriteRuleSubtreeStream stream_correlation_name=new RewriteRuleSubtreeStream(adaptor,"rule correlation_name");
1433 try {
1434
1435 int alt14=3;
1436 switch ( input.LA(1) ) {
1437 case LPAR:
1438 {
1439 alt14=1;
1440 }
1441 break;
1442 case ID:
1443 {
1444 switch ( input.LA(2) ) {
1445 case EOF:
1446 case JOIN:
1447 case INNER:
1448 case LEFT:
1449 case RIGHT:
1450 case ON:
1451 case WHERE:
1452 case ORDER:
1453 case RPAR:
1454 {
1455 alt14=2;
1456 }
1457 break;
1458 case AS:
1459 case ID:
1460 {
1461 alt14=3;
1462 }
1463 break;
1464 default:
1465 NoViableAltException nvae =
1466 new NoViableAltException("", 14, 2, input);
1467
1468 throw nvae;
1469 }
1470
1471 }
1472 break;
1473 default:
1474 NoViableAltException nvae =
1475 new NoViableAltException("", 14, 0, input);
1476
1477 throw nvae;
1478 }
1479
1480 switch (alt14) {
1481 case 1 :
1482
1483 {
1484 root_0 = (Object)adaptor.nil();
1485
1486 LPAR35=(Token)match(input,LPAR,FOLLOW_LPAR_in_one_table415);
1487 pushFollow(FOLLOW_table_reference_in_one_table418);
1488 table_reference36=table_reference();
1489
1490 state._fsp--;
1491
1492 adaptor.addChild(root_0, table_reference36.getTree());
1493 RPAR37=(Token)match(input,RPAR,FOLLOW_RPAR_in_one_table420);
1494
1495 }
1496 break;
1497 case 2 :
1498
1499 {
1500 pushFollow(FOLLOW_table_name_in_one_table429);
1501 table_name38=table_name();
1502
1503 state._fsp--;
1504
1505 stream_table_name.add(table_name38.getTree());
1506
1507
1508
1509
1510
1511
1512
1513
1514
1515 retval.tree = root_0;
1516 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
1517
1518 root_0 = (Object)adaptor.nil();
1519
1520 {
1521
1522 {
1523 Object root_1 = (Object)adaptor.nil();
1524 root_1 = (Object)adaptor.becomeRoot((Object)adaptor.create(TABLE, "TABLE"), root_1);
1525
1526 adaptor.addChild(root_1, stream_table_name.nextTree());
1527
1528 adaptor.addChild(root_0, root_1);
1529 }
1530
1531 }
1532
1533 retval.tree = root_0;
1534 }
1535 break;
1536 case 3 :
1537
1538 {
1539 pushFollow(FOLLOW_table_name_in_one_table453);
1540 table_name39=table_name();
1541
1542 state._fsp--;
1543
1544 stream_table_name.add(table_name39.getTree());
1545
1546 int alt13=2;
1547 switch ( input.LA(1) ) {
1548 case AS:
1549 {
1550 alt13=1;
1551 }
1552 break;
1553 }
1554
1555 switch (alt13) {
1556 case 1 :
1557
1558 {
1559 AS40=(Token)match(input,AS,FOLLOW_AS_in_one_table455);
1560 stream_AS.add(AS40);
1561
1562
1563 }
1564 break;
1565
1566 }
1567
1568 pushFollow(FOLLOW_correlation_name_in_one_table458);
1569 correlation_name41=correlation_name();
1570
1571 state._fsp--;
1572
1573 stream_correlation_name.add(correlation_name41.getTree());
1574
1575
1576
1577
1578
1579
1580
1581
1582
1583 retval.tree = root_0;
1584 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
1585
1586 root_0 = (Object)adaptor.nil();
1587
1588 {
1589
1590 {
1591 Object root_1 = (Object)adaptor.nil();
1592 root_1 = (Object)adaptor.becomeRoot((Object)adaptor.create(TABLE, "TABLE"), root_1);
1593
1594 adaptor.addChild(root_1, stream_table_name.nextTree());
1595 adaptor.addChild(root_1, stream_correlation_name.nextTree());
1596
1597 adaptor.addChild(root_0, root_1);
1598 }
1599
1600 }
1601
1602 retval.tree = root_0;
1603 }
1604 break;
1605
1606 }
1607 retval.stop = input.LT(-1);
1608
1609 retval.tree = (Object)adaptor.rulePostProcessing(root_0);
1610 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
1611
1612 }
1613 catch (RecognitionException re) {
1614 reportError(re);
1615 recover(input,re);
1616 retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
1617
1618 }
1619 finally {
1620 }
1621 return retval;
1622 }
1623
1624
1625 public static class join_kind_return extends ParserRuleReturnScope {
1626 Object tree;
1627 public Object getTree() { return tree; }
1628 };
1629
1630
1631
1632 public final CmisQlStrictParser_CmisBaseGrammar.join_kind_return join_kind() throws RecognitionException {
1633 CmisQlStrictParser_CmisBaseGrammar.join_kind_return retval = new CmisQlStrictParser_CmisBaseGrammar.join_kind_return();
1634 retval.start = input.LT(1);
1635
1636 Object root_0 = null;
1637
1638 Token JOIN42=null;
1639 Token INNER43=null;
1640 Token JOIN44=null;
1641 Token LEFT45=null;
1642 Token OUTER46=null;
1643 Token JOIN47=null;
1644 Token RIGHT48=null;
1645 Token OUTER49=null;
1646 Token JOIN50=null;
1647
1648 Object JOIN42_tree=null;
1649 Object INNER43_tree=null;
1650 Object JOIN44_tree=null;
1651 Object LEFT45_tree=null;
1652 Object OUTER46_tree=null;
1653 Object JOIN47_tree=null;
1654 Object RIGHT48_tree=null;
1655 Object OUTER49_tree=null;
1656 Object JOIN50_tree=null;
1657 RewriteRuleTokenStream stream_OUTER=new RewriteRuleTokenStream(adaptor,"token OUTER");
1658 RewriteRuleTokenStream stream_RIGHT=new RewriteRuleTokenStream(adaptor,"token RIGHT");
1659 RewriteRuleTokenStream stream_INNER=new RewriteRuleTokenStream(adaptor,"token INNER");
1660 RewriteRuleTokenStream stream_LEFT=new RewriteRuleTokenStream(adaptor,"token LEFT");
1661 RewriteRuleTokenStream stream_JOIN=new RewriteRuleTokenStream(adaptor,"token JOIN");
1662
1663 try {
1664
1665 int alt17=4;
1666 switch ( input.LA(1) ) {
1667 case JOIN:
1668 {
1669 alt17=1;
1670 }
1671 break;
1672 case INNER:
1673 {
1674 alt17=2;
1675 }
1676 break;
1677 case LEFT:
1678 {
1679 alt17=3;
1680 }
1681 break;
1682 case RIGHT:
1683 {
1684 alt17=4;
1685 }
1686 break;
1687 default:
1688 NoViableAltException nvae =
1689 new NoViableAltException("", 17, 0, input);
1690
1691 throw nvae;
1692 }
1693
1694 switch (alt17) {
1695 case 1 :
1696
1697 {
1698 JOIN42=(Token)match(input,JOIN,FOLLOW_JOIN_in_join_kind494);
1699 stream_JOIN.add(JOIN42);
1700
1701
1702
1703
1704
1705
1706
1707
1708
1709
1710 retval.tree = root_0;
1711 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
1712
1713 root_0 = (Object)adaptor.nil();
1714
1715 {
1716 adaptor.addChild(root_0, (Object)adaptor.create(INNER, "INNER"));
1717
1718 }
1719
1720 retval.tree = root_0;
1721 }
1722 break;
1723 case 2 :
1724
1725 {
1726 INNER43=(Token)match(input,INNER,FOLLOW_INNER_in_join_kind514);
1727 stream_INNER.add(INNER43);
1728
1729 JOIN44=(Token)match(input,JOIN,FOLLOW_JOIN_in_join_kind516);
1730 stream_JOIN.add(JOIN44);
1731
1732
1733
1734
1735
1736
1737
1738
1739
1740
1741 retval.tree = root_0;
1742 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
1743
1744 root_0 = (Object)adaptor.nil();
1745
1746 {
1747 adaptor.addChild(root_0, stream_INNER.nextNode());
1748
1749 }
1750
1751 retval.tree = root_0;
1752 }
1753 break;
1754 case 3 :
1755
1756 {
1757 LEFT45=(Token)match(input,LEFT,FOLLOW_LEFT_in_join_kind536);
1758 stream_LEFT.add(LEFT45);
1759
1760
1761 int alt15=2;
1762 switch ( input.LA(1) ) {
1763 case OUTER:
1764 {
1765 alt15=1;
1766 }
1767 break;
1768 }
1769
1770 switch (alt15) {
1771 case 1 :
1772
1773 {
1774 OUTER46=(Token)match(input,OUTER,FOLLOW_OUTER_in_join_kind538);
1775 stream_OUTER.add(OUTER46);
1776
1777
1778 }
1779 break;
1780
1781 }
1782
1783 JOIN47=(Token)match(input,JOIN,FOLLOW_JOIN_in_join_kind541);
1784 stream_JOIN.add(JOIN47);
1785
1786
1787
1788
1789
1790
1791
1792
1793
1794
1795 retval.tree = root_0;
1796 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
1797
1798 root_0 = (Object)adaptor.nil();
1799
1800 {
1801 adaptor.addChild(root_0, stream_LEFT.nextNode());
1802
1803 }
1804
1805 retval.tree = root_0;
1806 }
1807 break;
1808 case 4 :
1809
1810 {
1811 RIGHT48=(Token)match(input,RIGHT,FOLLOW_RIGHT_in_join_kind561);
1812 stream_RIGHT.add(RIGHT48);
1813
1814
1815 int alt16=2;
1816 switch ( input.LA(1) ) {
1817 case OUTER:
1818 {
1819 alt16=1;
1820 }
1821 break;
1822 }
1823
1824 switch (alt16) {
1825 case 1 :
1826
1827 {
1828 OUTER49=(Token)match(input,OUTER,FOLLOW_OUTER_in_join_kind563);
1829 stream_OUTER.add(OUTER49);
1830
1831
1832 }
1833 break;
1834
1835 }
1836
1837 JOIN50=(Token)match(input,JOIN,FOLLOW_JOIN_in_join_kind566);
1838 stream_JOIN.add(JOIN50);
1839
1840
1841
1842
1843
1844
1845
1846
1847
1848
1849 retval.tree = root_0;
1850 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
1851
1852 root_0 = (Object)adaptor.nil();
1853
1854 {
1855 adaptor.addChild(root_0, stream_RIGHT.nextNode());
1856
1857 }
1858
1859 retval.tree = root_0;
1860 }
1861 break;
1862
1863 }
1864 retval.stop = input.LT(-1);
1865
1866 retval.tree = (Object)adaptor.rulePostProcessing(root_0);
1867 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
1868
1869 }
1870 catch (RecognitionException re) {
1871 reportError(re);
1872 recover(input,re);
1873 retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
1874
1875 }
1876 finally {
1877 }
1878 return retval;
1879 }
1880
1881
1882 public static class join_specification_return extends ParserRuleReturnScope {
1883 Object tree;
1884 public Object getTree() { return tree; }
1885 };
1886
1887
1888
1889 public final CmisQlStrictParser_CmisBaseGrammar.join_specification_return join_specification() throws RecognitionException {
1890 CmisQlStrictParser_CmisBaseGrammar.join_specification_return retval = new CmisQlStrictParser_CmisBaseGrammar.join_specification_return();
1891 retval.start = input.LT(1);
1892
1893 Object root_0 = null;
1894
1895 Token ON51=null;
1896 Token EQ53=null;
1897 CmisQlStrictParser_CmisBaseGrammar.column_reference_return column_reference52 = null;
1898
1899 CmisQlStrictParser_CmisBaseGrammar.column_reference_return column_reference54 = null;
1900
1901
1902 Object ON51_tree=null;
1903 Object EQ53_tree=null;
1904
1905 try {
1906
1907
1908 {
1909 root_0 = (Object)adaptor.nil();
1910
1911 ON51=(Token)match(input,ON,FOLLOW_ON_in_join_specification594);
1912 ON51_tree = (Object)adaptor.create(ON51);
1913 root_0 = (Object)adaptor.becomeRoot(ON51_tree, root_0);
1914
1915 pushFollow(FOLLOW_column_reference_in_join_specification597);
1916 column_reference52=column_reference();
1917
1918 state._fsp--;
1919
1920 adaptor.addChild(root_0, column_reference52.getTree());
1921 EQ53=(Token)match(input,EQ,FOLLOW_EQ_in_join_specification599);
1922 EQ53_tree = (Object)adaptor.create(EQ53);
1923 adaptor.addChild(root_0, EQ53_tree);
1924
1925 pushFollow(FOLLOW_column_reference_in_join_specification601);
1926 column_reference54=column_reference();
1927
1928 state._fsp--;
1929
1930 adaptor.addChild(root_0, column_reference54.getTree());
1931
1932 }
1933
1934 retval.stop = input.LT(-1);
1935
1936 retval.tree = (Object)adaptor.rulePostProcessing(root_0);
1937 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
1938
1939 }
1940 catch (RecognitionException re) {
1941 reportError(re);
1942 recover(input,re);
1943 retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
1944
1945 }
1946 finally {
1947 }
1948 return retval;
1949 }
1950
1951
1952 public static class where_clause_return extends ParserRuleReturnScope {
1953 Object tree;
1954 public Object getTree() { return tree; }
1955 };
1956
1957
1958
1959 public final CmisQlStrictParser_CmisBaseGrammar.where_clause_return where_clause() throws RecognitionException {
1960 CmisQlStrictParser_CmisBaseGrammar.where_clause_return retval = new CmisQlStrictParser_CmisBaseGrammar.where_clause_return();
1961 retval.start = input.LT(1);
1962
1963 Object root_0 = null;
1964
1965 Token WHERE55=null;
1966 CmisQlStrictParser_CmisBaseGrammar.search_condition_return search_condition56 = null;
1967
1968
1969 Object WHERE55_tree=null;
1970
1971 try {
1972
1973
1974 {
1975 root_0 = (Object)adaptor.nil();
1976
1977 WHERE55=(Token)match(input,WHERE,FOLLOW_WHERE_in_where_clause616);
1978 WHERE55_tree = (Object)adaptor.create(WHERE55);
1979 root_0 = (Object)adaptor.becomeRoot(WHERE55_tree, root_0);
1980
1981 pushFollow(FOLLOW_search_condition_in_where_clause619);
1982 search_condition56=search_condition();
1983
1984 state._fsp--;
1985
1986 adaptor.addChild(root_0, search_condition56.getTree());
1987
1988 }
1989
1990 retval.stop = input.LT(-1);
1991
1992 retval.tree = (Object)adaptor.rulePostProcessing(root_0);
1993 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
1994
1995 }
1996 catch (RecognitionException re) {
1997 reportError(re);
1998 recover(input,re);
1999 retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
2000
2001 }
2002 finally {
2003 }
2004 return retval;
2005 }
2006
2007
2008 public static class search_condition_return extends ParserRuleReturnScope {
2009 Object tree;
2010 public Object getTree() { return tree; }
2011 };
2012
2013
2014
2015 public final CmisQlStrictParser_CmisBaseGrammar.search_condition_return search_condition() throws RecognitionException {
2016 CmisQlStrictParser_CmisBaseGrammar.search_condition_return retval = new CmisQlStrictParser_CmisBaseGrammar.search_condition_return();
2017 retval.start = input.LT(1);
2018
2019 Object root_0 = null;
2020
2021 Token OR58=null;
2022 CmisQlStrictParser_CmisBaseGrammar.boolean_term_return boolean_term57 = null;
2023
2024 CmisQlStrictParser_CmisBaseGrammar.boolean_term_return boolean_term59 = null;
2025
2026
2027 Object OR58_tree=null;
2028
2029 try {
2030
2031
2032 {
2033 root_0 = (Object)adaptor.nil();
2034
2035 pushFollow(FOLLOW_boolean_term_in_search_condition630);
2036 boolean_term57=boolean_term();
2037
2038 state._fsp--;
2039
2040 adaptor.addChild(root_0, boolean_term57.getTree());
2041
2042 loop18:
2043 do {
2044 int alt18=2;
2045 switch ( input.LA(1) ) {
2046 case OR:
2047 {
2048 alt18=1;
2049 }
2050 break;
2051
2052 }
2053
2054 switch (alt18) {
2055 case 1 :
2056
2057 {
2058 OR58=(Token)match(input,OR,FOLLOW_OR_in_search_condition633);
2059 OR58_tree = (Object)adaptor.create(OR58);
2060 root_0 = (Object)adaptor.becomeRoot(OR58_tree, root_0);
2061
2062 pushFollow(FOLLOW_boolean_term_in_search_condition636);
2063 boolean_term59=boolean_term();
2064
2065 state._fsp--;
2066
2067 adaptor.addChild(root_0, boolean_term59.getTree());
2068
2069 }
2070 break;
2071
2072 default :
2073 break loop18;
2074 }
2075 } while (true);
2076
2077
2078 }
2079
2080 retval.stop = input.LT(-1);
2081
2082 retval.tree = (Object)adaptor.rulePostProcessing(root_0);
2083 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
2084
2085 }
2086 catch (RecognitionException re) {
2087 reportError(re);
2088 recover(input,re);
2089 retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
2090
2091 }
2092 finally {
2093 }
2094 return retval;
2095 }
2096
2097
2098 public static class boolean_term_return extends ParserRuleReturnScope {
2099 Object tree;
2100 public Object getTree() { return tree; }
2101 };
2102
2103
2104
2105 public final CmisQlStrictParser_CmisBaseGrammar.boolean_term_return boolean_term() throws RecognitionException {
2106 CmisQlStrictParser_CmisBaseGrammar.boolean_term_return retval = new CmisQlStrictParser_CmisBaseGrammar.boolean_term_return();
2107 retval.start = input.LT(1);
2108
2109 Object root_0 = null;
2110
2111 Token AND61=null;
2112 CmisQlStrictParser_CmisBaseGrammar.boolean_factor_return boolean_factor60 = null;
2113
2114 CmisQlStrictParser_CmisBaseGrammar.boolean_factor_return boolean_factor62 = null;
2115
2116
2117 Object AND61_tree=null;
2118
2119 try {
2120
2121
2122 {
2123 root_0 = (Object)adaptor.nil();
2124
2125 pushFollow(FOLLOW_boolean_factor_in_boolean_term649);
2126 boolean_factor60=boolean_factor();
2127
2128 state._fsp--;
2129
2130 adaptor.addChild(root_0, boolean_factor60.getTree());
2131
2132 loop19:
2133 do {
2134 int alt19=2;
2135 switch ( input.LA(1) ) {
2136 case AND:
2137 {
2138 alt19=1;
2139 }
2140 break;
2141
2142 }
2143
2144 switch (alt19) {
2145 case 1 :
2146
2147 {
2148 AND61=(Token)match(input,AND,FOLLOW_AND_in_boolean_term652);
2149 AND61_tree = (Object)adaptor.create(AND61);
2150 root_0 = (Object)adaptor.becomeRoot(AND61_tree, root_0);
2151
2152 pushFollow(FOLLOW_boolean_factor_in_boolean_term655);
2153 boolean_factor62=boolean_factor();
2154
2155 state._fsp--;
2156
2157 adaptor.addChild(root_0, boolean_factor62.getTree());
2158
2159 }
2160 break;
2161
2162 default :
2163 break loop19;
2164 }
2165 } while (true);
2166
2167
2168 }
2169
2170 retval.stop = input.LT(-1);
2171
2172 retval.tree = (Object)adaptor.rulePostProcessing(root_0);
2173 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
2174
2175 }
2176 catch (RecognitionException re) {
2177 reportError(re);
2178 recover(input,re);
2179 retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
2180
2181 }
2182 finally {
2183 }
2184 return retval;
2185 }
2186
2187
2188 public static class boolean_factor_return extends ParserRuleReturnScope {
2189 Object tree;
2190 public Object getTree() { return tree; }
2191 };
2192
2193
2194
2195 public final CmisQlStrictParser_CmisBaseGrammar.boolean_factor_return boolean_factor() throws RecognitionException {
2196 CmisQlStrictParser_CmisBaseGrammar.boolean_factor_return retval = new CmisQlStrictParser_CmisBaseGrammar.boolean_factor_return();
2197 retval.start = input.LT(1);
2198
2199 Object root_0 = null;
2200
2201 Token NOT63=null;
2202 CmisQlStrictParser_CmisBaseGrammar.boolean_test_return boolean_test64 = null;
2203
2204 CmisQlStrictParser_CmisBaseGrammar.boolean_test_return boolean_test65 = null;
2205
2206
2207 Object NOT63_tree=null;
2208
2209 try {
2210
2211 int alt20=2;
2212 switch ( input.LA(1) ) {
2213 case NOT:
2214 {
2215 alt20=1;
2216 }
2217 break;
2218 case ANY:
2219 case CONTAINS:
2220 case SCORE:
2221 case IN_FOLDER:
2222 case IN_TREE:
2223 case LPAR:
2224 case BOOL_LIT:
2225 case NUM_LIT:
2226 case STRING_LIT:
2227 case TIME_LIT:
2228 case ID:
2229 {
2230 alt20=2;
2231 }
2232 break;
2233 default:
2234 NoViableAltException nvae =
2235 new NoViableAltException("", 20, 0, input);
2236
2237 throw nvae;
2238 }
2239
2240 switch (alt20) {
2241 case 1 :
2242
2243 {
2244 root_0 = (Object)adaptor.nil();
2245
2246 NOT63=(Token)match(input,NOT,FOLLOW_NOT_in_boolean_factor668);
2247 NOT63_tree = (Object)adaptor.create(NOT63);
2248 root_0 = (Object)adaptor.becomeRoot(NOT63_tree, root_0);
2249
2250 pushFollow(FOLLOW_boolean_test_in_boolean_factor671);
2251 boolean_test64=boolean_test();
2252
2253 state._fsp--;
2254
2255 adaptor.addChild(root_0, boolean_test64.getTree());
2256
2257 }
2258 break;
2259 case 2 :
2260
2261 {
2262 root_0 = (Object)adaptor.nil();
2263
2264 pushFollow(FOLLOW_boolean_test_in_boolean_factor679);
2265 boolean_test65=boolean_test();
2266
2267 state._fsp--;
2268
2269 adaptor.addChild(root_0, boolean_test65.getTree());
2270
2271 }
2272 break;
2273
2274 }
2275 retval.stop = input.LT(-1);
2276
2277 retval.tree = (Object)adaptor.rulePostProcessing(root_0);
2278 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
2279
2280 }
2281 catch (RecognitionException re) {
2282 reportError(re);
2283 recover(input,re);
2284 retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
2285
2286 }
2287 finally {
2288 }
2289 return retval;
2290 }
2291
2292
2293 public static class boolean_test_return extends ParserRuleReturnScope {
2294 Object tree;
2295 public Object getTree() { return tree; }
2296 };
2297
2298
2299
2300 public final CmisQlStrictParser_CmisBaseGrammar.boolean_test_return boolean_test() throws RecognitionException {
2301 CmisQlStrictParser_CmisBaseGrammar.boolean_test_return retval = new CmisQlStrictParser_CmisBaseGrammar.boolean_test_return();
2302 retval.start = input.LT(1);
2303
2304 Object root_0 = null;
2305
2306 Token LPAR67=null;
2307 Token RPAR69=null;
2308 CmisQlStrictParser_CmisBaseGrammar.predicate_return predicate66 = null;
2309
2310 CmisQlStrictParser_CmisBaseGrammar.search_condition_return search_condition68 = null;
2311
2312
2313 Object LPAR67_tree=null;
2314 Object RPAR69_tree=null;
2315 RewriteRuleTokenStream stream_RPAR=new RewriteRuleTokenStream(adaptor,"token RPAR");
2316 RewriteRuleTokenStream stream_LPAR=new RewriteRuleTokenStream(adaptor,"token LPAR");
2317 RewriteRuleSubtreeStream stream_search_condition=new RewriteRuleSubtreeStream(adaptor,"rule search_condition");
2318 try {
2319
2320 int alt21=2;
2321 switch ( input.LA(1) ) {
2322 case ANY:
2323 case CONTAINS:
2324 case SCORE:
2325 case IN_FOLDER:
2326 case IN_TREE:
2327 case BOOL_LIT:
2328 case NUM_LIT:
2329 case STRING_LIT:
2330 case TIME_LIT:
2331 case ID:
2332 {
2333 alt21=1;
2334 }
2335 break;
2336 case LPAR:
2337 {
2338 alt21=2;
2339 }
2340 break;
2341 default:
2342 NoViableAltException nvae =
2343 new NoViableAltException("", 21, 0, input);
2344
2345 throw nvae;
2346 }
2347
2348 switch (alt21) {
2349 case 1 :
2350
2351 {
2352 root_0 = (Object)adaptor.nil();
2353
2354 pushFollow(FOLLOW_predicate_in_boolean_test695);
2355 predicate66=predicate();
2356
2357 state._fsp--;
2358
2359 adaptor.addChild(root_0, predicate66.getTree());
2360
2361 }
2362 break;
2363 case 2 :
2364
2365 {
2366 LPAR67=(Token)match(input,LPAR,FOLLOW_LPAR_in_boolean_test703);
2367 stream_LPAR.add(LPAR67);
2368
2369 pushFollow(FOLLOW_search_condition_in_boolean_test705);
2370 search_condition68=search_condition();
2371
2372 state._fsp--;
2373
2374 stream_search_condition.add(search_condition68.getTree());
2375 RPAR69=(Token)match(input,RPAR,FOLLOW_RPAR_in_boolean_test707);
2376 stream_RPAR.add(RPAR69);
2377
2378
2379
2380
2381
2382
2383
2384
2385
2386
2387 retval.tree = root_0;
2388 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
2389
2390 root_0 = (Object)adaptor.nil();
2391
2392 {
2393 adaptor.addChild(root_0, stream_search_condition.nextTree());
2394
2395 }
2396
2397 retval.tree = root_0;
2398 }
2399 break;
2400
2401 }
2402 retval.stop = input.LT(-1);
2403
2404 retval.tree = (Object)adaptor.rulePostProcessing(root_0);
2405 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
2406
2407 }
2408 catch (RecognitionException re) {
2409 reportError(re);
2410 recover(input,re);
2411 retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
2412
2413 }
2414 finally {
2415 }
2416 return retval;
2417 }
2418
2419
2420 public static class predicate_return extends ParserRuleReturnScope {
2421 Object tree;
2422 public Object getTree() { return tree; }
2423 };
2424
2425
2426
2427 public final CmisQlStrictParser_CmisBaseGrammar.predicate_return predicate() throws RecognitionException {
2428 CmisQlStrictParser_CmisBaseGrammar.predicate_return retval = new CmisQlStrictParser_CmisBaseGrammar.predicate_return();
2429 retval.start = input.LT(1);
2430
2431 Object root_0 = null;
2432
2433 CmisQlStrictParser_CmisBaseGrammar.comparison_predicate_return comparison_predicate70 = null;
2434
2435 CmisQlStrictParser_CmisBaseGrammar.in_predicate_return in_predicate71 = null;
2436
2437 CmisQlStrictParser_CmisBaseGrammar.like_predicate_return like_predicate72 = null;
2438
2439 CmisQlStrictParser_CmisBaseGrammar.null_predicate_return null_predicate73 = null;
2440
2441 CmisQlStrictParser_CmisBaseGrammar.quantified_comparison_predicate_return quantified_comparison_predicate74 = null;
2442
2443 CmisQlStrictParser_CmisBaseGrammar.quantified_in_predicate_return quantified_in_predicate75 = null;
2444
2445 CmisQlStrictParser_CmisBaseGrammar.text_search_predicate_return text_search_predicate76 = null;
2446
2447 CmisQlStrictParser_CmisBaseGrammar.folder_predicate_return folder_predicate77 = null;
2448
2449
2450
2451 try {
2452
2453 int alt22=8;
2454 alt22 = dfa22.predict(input);
2455 switch (alt22) {
2456 case 1 :
2457
2458 {
2459 root_0 = (Object)adaptor.nil();
2460
2461 pushFollow(FOLLOW_comparison_predicate_in_predicate729);
2462 comparison_predicate70=comparison_predicate();
2463
2464 state._fsp--;
2465
2466 adaptor.addChild(root_0, comparison_predicate70.getTree());
2467
2468 }
2469 break;
2470 case 2 :
2471
2472 {
2473 root_0 = (Object)adaptor.nil();
2474
2475 pushFollow(FOLLOW_in_predicate_in_predicate737);
2476 in_predicate71=in_predicate();
2477
2478 state._fsp--;
2479
2480 adaptor.addChild(root_0, in_predicate71.getTree());
2481
2482 }
2483 break;
2484 case 3 :
2485
2486 {
2487 root_0 = (Object)adaptor.nil();
2488
2489 pushFollow(FOLLOW_like_predicate_in_predicate745);
2490 like_predicate72=like_predicate();
2491
2492 state._fsp--;
2493
2494 adaptor.addChild(root_0, like_predicate72.getTree());
2495
2496 }
2497 break;
2498 case 4 :
2499
2500 {
2501 root_0 = (Object)adaptor.nil();
2502
2503 pushFollow(FOLLOW_null_predicate_in_predicate753);
2504 null_predicate73=null_predicate();
2505
2506 state._fsp--;
2507
2508 adaptor.addChild(root_0, null_predicate73.getTree());
2509
2510 }
2511 break;
2512 case 5 :
2513
2514 {
2515 root_0 = (Object)adaptor.nil();
2516
2517 pushFollow(FOLLOW_quantified_comparison_predicate_in_predicate761);
2518 quantified_comparison_predicate74=quantified_comparison_predicate();
2519
2520 state._fsp--;
2521
2522 adaptor.addChild(root_0, quantified_comparison_predicate74.getTree());
2523
2524 }
2525 break;
2526 case 6 :
2527
2528 {
2529 root_0 = (Object)adaptor.nil();
2530
2531 pushFollow(FOLLOW_quantified_in_predicate_in_predicate769);
2532 quantified_in_predicate75=quantified_in_predicate();
2533
2534 state._fsp--;
2535
2536 adaptor.addChild(root_0, quantified_in_predicate75.getTree());
2537
2538 }
2539 break;
2540 case 7 :
2541
2542 {
2543 root_0 = (Object)adaptor.nil();
2544
2545 pushFollow(FOLLOW_text_search_predicate_in_predicate777);
2546 text_search_predicate76=text_search_predicate();
2547
2548 state._fsp--;
2549
2550 adaptor.addChild(root_0, text_search_predicate76.getTree());
2551
2552 }
2553 break;
2554 case 8 :
2555
2556 {
2557 root_0 = (Object)adaptor.nil();
2558
2559 pushFollow(FOLLOW_folder_predicate_in_predicate785);
2560 folder_predicate77=folder_predicate();
2561
2562 state._fsp--;
2563
2564 adaptor.addChild(root_0, folder_predicate77.getTree());
2565
2566 }
2567 break;
2568
2569 }
2570 retval.stop = input.LT(-1);
2571
2572 retval.tree = (Object)adaptor.rulePostProcessing(root_0);
2573 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
2574
2575 }
2576 catch (RecognitionException re) {
2577 reportError(re);
2578 recover(input,re);
2579 retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
2580
2581 }
2582 finally {
2583 }
2584 return retval;
2585 }
2586
2587
2588 public static class comparison_predicate_return extends ParserRuleReturnScope {
2589 Object tree;
2590 public Object getTree() { return tree; }
2591 };
2592
2593
2594
2595 public final CmisQlStrictParser_CmisBaseGrammar.comparison_predicate_return comparison_predicate() throws RecognitionException {
2596 CmisQlStrictParser_CmisBaseGrammar.comparison_predicate_return retval = new CmisQlStrictParser_CmisBaseGrammar.comparison_predicate_return();
2597 retval.start = input.LT(1);
2598
2599 Object root_0 = null;
2600
2601 Token EQ79=null;
2602 Token NEQ82=null;
2603 Token LT85=null;
2604 Token GT88=null;
2605 Token LTEQ91=null;
2606 Token GTEQ94=null;
2607 CmisQlStrictParser_CmisBaseGrammar.value_expression_return value_expression78 = null;
2608
2609 CmisQlStrictParser_CmisBaseGrammar.literal_return literal80 = null;
2610
2611 CmisQlStrictParser_CmisBaseGrammar.value_expression_return value_expression81 = null;
2612
2613 CmisQlStrictParser_CmisBaseGrammar.literal_return literal83 = null;
2614
2615 CmisQlStrictParser_CmisBaseGrammar.value_expression_return value_expression84 = null;
2616
2617 CmisQlStrictParser_CmisBaseGrammar.literal_return literal86 = null;
2618
2619 CmisQlStrictParser_CmisBaseGrammar.value_expression_return value_expression87 = null;
2620
2621 CmisQlStrictParser_CmisBaseGrammar.literal_return literal89 = null;
2622
2623 CmisQlStrictParser_CmisBaseGrammar.value_expression_return value_expression90 = null;
2624
2625 CmisQlStrictParser_CmisBaseGrammar.literal_return literal92 = null;
2626
2627 CmisQlStrictParser_CmisBaseGrammar.value_expression_return value_expression93 = null;
2628
2629 CmisQlStrictParser_CmisBaseGrammar.literal_return literal95 = null;
2630
2631
2632 Object EQ79_tree=null;
2633 Object NEQ82_tree=null;
2634 Object LT85_tree=null;
2635 Object GT88_tree=null;
2636 Object LTEQ91_tree=null;
2637 Object GTEQ94_tree=null;
2638 RewriteRuleTokenStream stream_GT=new RewriteRuleTokenStream(adaptor,"token GT");
2639 RewriteRuleTokenStream stream_LT=new RewriteRuleTokenStream(adaptor,"token LT");
2640 RewriteRuleTokenStream stream_NEQ=new RewriteRuleTokenStream(adaptor,"token NEQ");
2641 RewriteRuleTokenStream stream_GTEQ=new RewriteRuleTokenStream(adaptor,"token GTEQ");
2642 RewriteRuleTokenStream stream_EQ=new RewriteRuleTokenStream(adaptor,"token EQ");
2643 RewriteRuleTokenStream stream_LTEQ=new RewriteRuleTokenStream(adaptor,"token LTEQ");
2644 RewriteRuleSubtreeStream stream_value_expression=new RewriteRuleSubtreeStream(adaptor,"rule value_expression");
2645 RewriteRuleSubtreeStream stream_literal=new RewriteRuleSubtreeStream(adaptor,"rule literal");
2646 try {
2647
2648 int alt23=6;
2649 alt23 = dfa23.predict(input);
2650 switch (alt23) {
2651 case 1 :
2652
2653 {
2654 pushFollow(FOLLOW_value_expression_in_comparison_predicate801);
2655 value_expression78=value_expression();
2656
2657 state._fsp--;
2658
2659 stream_value_expression.add(value_expression78.getTree());
2660 EQ79=(Token)match(input,EQ,FOLLOW_EQ_in_comparison_predicate803);
2661 stream_EQ.add(EQ79);
2662
2663 pushFollow(FOLLOW_literal_in_comparison_predicate805);
2664 literal80=literal();
2665
2666 state._fsp--;
2667
2668 stream_literal.add(literal80.getTree());
2669
2670
2671
2672
2673
2674
2675
2676
2677
2678 retval.tree = root_0;
2679 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
2680
2681 root_0 = (Object)adaptor.nil();
2682
2683 {
2684
2685 {
2686 Object root_1 = (Object)adaptor.nil();
2687 root_1 = (Object)adaptor.becomeRoot(stream_EQ.nextNode(), root_1);
2688
2689 adaptor.addChild(root_1, stream_value_expression.nextTree());
2690 adaptor.addChild(root_1, stream_literal.nextTree());
2691
2692 adaptor.addChild(root_0, root_1);
2693 }
2694
2695 }
2696
2697 retval.tree = root_0;
2698 }
2699 break;
2700 case 2 :
2701
2702 {
2703 pushFollow(FOLLOW_value_expression_in_comparison_predicate829);
2704 value_expression81=value_expression();
2705
2706 state._fsp--;
2707
2708 stream_value_expression.add(value_expression81.getTree());
2709 NEQ82=(Token)match(input,NEQ,FOLLOW_NEQ_in_comparison_predicate831);
2710 stream_NEQ.add(NEQ82);
2711
2712 pushFollow(FOLLOW_literal_in_comparison_predicate833);
2713 literal83=literal();
2714
2715 state._fsp--;
2716
2717 stream_literal.add(literal83.getTree());
2718
2719
2720
2721
2722
2723
2724
2725
2726
2727 retval.tree = root_0;
2728 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
2729
2730 root_0 = (Object)adaptor.nil();
2731
2732 {
2733
2734 {
2735 Object root_1 = (Object)adaptor.nil();
2736 root_1 = (Object)adaptor.becomeRoot(stream_NEQ.nextNode(), root_1);
2737
2738 adaptor.addChild(root_1, stream_value_expression.nextTree());
2739 adaptor.addChild(root_1, stream_literal.nextTree());
2740
2741 adaptor.addChild(root_0, root_1);
2742 }
2743
2744 }
2745
2746 retval.tree = root_0;
2747 }
2748 break;
2749 case 3 :
2750
2751 {
2752 pushFollow(FOLLOW_value_expression_in_comparison_predicate857);
2753 value_expression84=value_expression();
2754
2755 state._fsp--;
2756
2757 stream_value_expression.add(value_expression84.getTree());
2758 LT85=(Token)match(input,LT,FOLLOW_LT_in_comparison_predicate859);
2759 stream_LT.add(LT85);
2760
2761 pushFollow(FOLLOW_literal_in_comparison_predicate861);
2762 literal86=literal();
2763
2764 state._fsp--;
2765
2766 stream_literal.add(literal86.getTree());
2767
2768
2769
2770
2771
2772
2773
2774
2775
2776 retval.tree = root_0;
2777 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
2778
2779 root_0 = (Object)adaptor.nil();
2780
2781 {
2782
2783 {
2784 Object root_1 = (Object)adaptor.nil();
2785 root_1 = (Object)adaptor.becomeRoot(stream_LT.nextNode(), root_1);
2786
2787 adaptor.addChild(root_1, stream_value_expression.nextTree());
2788 adaptor.addChild(root_1, stream_literal.nextTree());
2789
2790 adaptor.addChild(root_0, root_1);
2791 }
2792
2793 }
2794
2795 retval.tree = root_0;
2796 }
2797 break;
2798 case 4 :
2799
2800 {
2801 pushFollow(FOLLOW_value_expression_in_comparison_predicate885);
2802 value_expression87=value_expression();
2803
2804 state._fsp--;
2805
2806 stream_value_expression.add(value_expression87.getTree());
2807 GT88=(Token)match(input,GT,FOLLOW_GT_in_comparison_predicate887);
2808 stream_GT.add(GT88);
2809
2810 pushFollow(FOLLOW_literal_in_comparison_predicate889);
2811 literal89=literal();
2812
2813 state._fsp--;
2814
2815 stream_literal.add(literal89.getTree());
2816
2817
2818
2819
2820
2821
2822
2823
2824
2825 retval.tree = root_0;
2826 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
2827
2828 root_0 = (Object)adaptor.nil();
2829
2830 {
2831
2832 {
2833 Object root_1 = (Object)adaptor.nil();
2834 root_1 = (Object)adaptor.becomeRoot(stream_GT.nextNode(), root_1);
2835
2836 adaptor.addChild(root_1, stream_value_expression.nextTree());
2837 adaptor.addChild(root_1, stream_literal.nextTree());
2838
2839 adaptor.addChild(root_0, root_1);
2840 }
2841
2842 }
2843
2844 retval.tree = root_0;
2845 }
2846 break;
2847 case 5 :
2848
2849 {
2850 pushFollow(FOLLOW_value_expression_in_comparison_predicate913);
2851 value_expression90=value_expression();
2852
2853 state._fsp--;
2854
2855 stream_value_expression.add(value_expression90.getTree());
2856 LTEQ91=(Token)match(input,LTEQ,FOLLOW_LTEQ_in_comparison_predicate915);
2857 stream_LTEQ.add(LTEQ91);
2858
2859 pushFollow(FOLLOW_literal_in_comparison_predicate917);
2860 literal92=literal();
2861
2862 state._fsp--;
2863
2864 stream_literal.add(literal92.getTree());
2865
2866
2867
2868
2869
2870
2871
2872
2873
2874 retval.tree = root_0;
2875 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
2876
2877 root_0 = (Object)adaptor.nil();
2878
2879 {
2880
2881 {
2882 Object root_1 = (Object)adaptor.nil();
2883 root_1 = (Object)adaptor.becomeRoot(stream_LTEQ.nextNode(), root_1);
2884
2885 adaptor.addChild(root_1, stream_value_expression.nextTree());
2886 adaptor.addChild(root_1, stream_literal.nextTree());
2887
2888 adaptor.addChild(root_0, root_1);
2889 }
2890
2891 }
2892
2893 retval.tree = root_0;
2894 }
2895 break;
2896 case 6 :
2897
2898 {
2899 pushFollow(FOLLOW_value_expression_in_comparison_predicate941);
2900 value_expression93=value_expression();
2901
2902 state._fsp--;
2903
2904 stream_value_expression.add(value_expression93.getTree());
2905 GTEQ94=(Token)match(input,GTEQ,FOLLOW_GTEQ_in_comparison_predicate943);
2906 stream_GTEQ.add(GTEQ94);
2907
2908 pushFollow(FOLLOW_literal_in_comparison_predicate945);
2909 literal95=literal();
2910
2911 state._fsp--;
2912
2913 stream_literal.add(literal95.getTree());
2914
2915
2916
2917
2918
2919
2920
2921
2922
2923 retval.tree = root_0;
2924 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
2925
2926 root_0 = (Object)adaptor.nil();
2927
2928 {
2929
2930 {
2931 Object root_1 = (Object)adaptor.nil();
2932 root_1 = (Object)adaptor.becomeRoot(stream_GTEQ.nextNode(), root_1);
2933
2934 adaptor.addChild(root_1, stream_value_expression.nextTree());
2935 adaptor.addChild(root_1, stream_literal.nextTree());
2936
2937 adaptor.addChild(root_0, root_1);
2938 }
2939
2940 }
2941
2942 retval.tree = root_0;
2943 }
2944 break;
2945
2946 }
2947 retval.stop = input.LT(-1);
2948
2949 retval.tree = (Object)adaptor.rulePostProcessing(root_0);
2950 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
2951
2952 }
2953 catch (RecognitionException re) {
2954 reportError(re);
2955 recover(input,re);
2956 retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
2957
2958 }
2959 finally {
2960 }
2961 return retval;
2962 }
2963
2964
2965 public static class literal_return extends ParserRuleReturnScope {
2966 Object tree;
2967 public Object getTree() { return tree; }
2968 };
2969
2970
2971
2972 public final CmisQlStrictParser_CmisBaseGrammar.literal_return literal() throws RecognitionException {
2973 CmisQlStrictParser_CmisBaseGrammar.literal_return retval = new CmisQlStrictParser_CmisBaseGrammar.literal_return();
2974 retval.start = input.LT(1);
2975
2976 Object root_0 = null;
2977
2978 Token set96=null;
2979
2980 Object set96_tree=null;
2981
2982 try {
2983
2984
2985 {
2986 root_0 = (Object)adaptor.nil();
2987
2988 set96=(Token)input.LT(1);
2989 if ( input.LA(1)==BOOL_LIT||input.LA(1)==NUM_LIT||input.LA(1)==STRING_LIT||input.LA(1)==TIME_LIT ) {
2990 input.consume();
2991 adaptor.addChild(root_0, (Object)adaptor.create(set96));
2992 state.errorRecovery=false;
2993 }
2994 else {
2995 MismatchedSetException mse = new MismatchedSetException(null,input);
2996 throw mse;
2997 }
2998
2999
3000 }
3001
3002 retval.stop = input.LT(-1);
3003
3004 retval.tree = (Object)adaptor.rulePostProcessing(root_0);
3005 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
3006
3007 }
3008 catch (RecognitionException re) {
3009 reportError(re);
3010 recover(input,re);
3011 retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
3012
3013 }
3014 finally {
3015 }
3016 return retval;
3017 }
3018
3019
3020 public static class in_predicate_return extends ParserRuleReturnScope {
3021 Object tree;
3022 public Object getTree() { return tree; }
3023 };
3024
3025
3026
3027 public final CmisQlStrictParser_CmisBaseGrammar.in_predicate_return in_predicate() throws RecognitionException {
3028 CmisQlStrictParser_CmisBaseGrammar.in_predicate_return retval = new CmisQlStrictParser_CmisBaseGrammar.in_predicate_return();
3029 retval.start = input.LT(1);
3030
3031 Object root_0 = null;
3032
3033 Token IN98=null;
3034 Token LPAR99=null;
3035 Token RPAR101=null;
3036 Token NOT103=null;
3037 Token IN104=null;
3038 Token LPAR105=null;
3039 Token RPAR107=null;
3040 CmisQlStrictParser_CmisBaseGrammar.column_reference_return column_reference97 = null;
3041
3042 CmisQlStrictParser_CmisBaseGrammar.in_value_list_return in_value_list100 = null;
3043
3044 CmisQlStrictParser_CmisBaseGrammar.column_reference_return column_reference102 = null;
3045
3046 CmisQlStrictParser_CmisBaseGrammar.in_value_list_return in_value_list106 = null;
3047
3048
3049 Object IN98_tree=null;
3050 Object LPAR99_tree=null;
3051 Object RPAR101_tree=null;
3052 Object NOT103_tree=null;
3053 Object IN104_tree=null;
3054 Object LPAR105_tree=null;
3055 Object RPAR107_tree=null;
3056 RewriteRuleTokenStream stream_RPAR=new RewriteRuleTokenStream(adaptor,"token RPAR");
3057 RewriteRuleTokenStream stream_IN=new RewriteRuleTokenStream(adaptor,"token IN");
3058 RewriteRuleTokenStream stream_NOT=new RewriteRuleTokenStream(adaptor,"token NOT");
3059 RewriteRuleTokenStream stream_LPAR=new RewriteRuleTokenStream(adaptor,"token LPAR");
3060 RewriteRuleSubtreeStream stream_column_reference=new RewriteRuleSubtreeStream(adaptor,"rule column_reference");
3061 RewriteRuleSubtreeStream stream_in_value_list=new RewriteRuleSubtreeStream(adaptor,"rule in_value_list");
3062 try {
3063
3064 int alt24=2;
3065 switch ( input.LA(1) ) {
3066 case ID:
3067 {
3068 switch ( input.LA(2) ) {
3069 case DOT:
3070 {
3071 switch ( input.LA(3) ) {
3072 case ID:
3073 {
3074 switch ( input.LA(4) ) {
3075 case IN:
3076 {
3077 alt24=1;
3078 }
3079 break;
3080 case NOT:
3081 {
3082 alt24=2;
3083 }
3084 break;
3085 default:
3086 NoViableAltException nvae =
3087 new NoViableAltException("", 24, 5, input);
3088
3089 throw nvae;
3090 }
3091
3092 }
3093 break;
3094 default:
3095 NoViableAltException nvae =
3096 new NoViableAltException("", 24, 2, input);
3097
3098 throw nvae;
3099 }
3100
3101 }
3102 break;
3103 case IN:
3104 {
3105 alt24=1;
3106 }
3107 break;
3108 case NOT:
3109 {
3110 alt24=2;
3111 }
3112 break;
3113 default:
3114 NoViableAltException nvae =
3115 new NoViableAltException("", 24, 1, input);
3116
3117 throw nvae;
3118 }
3119
3120 }
3121 break;
3122 default:
3123 NoViableAltException nvae =
3124 new NoViableAltException("", 24, 0, input);
3125
3126 throw nvae;
3127 }
3128
3129 switch (alt24) {
3130 case 1 :
3131
3132 {
3133 pushFollow(FOLLOW_column_reference_in_in_predicate1021);
3134 column_reference97=column_reference();
3135
3136 state._fsp--;
3137
3138 stream_column_reference.add(column_reference97.getTree());
3139 IN98=(Token)match(input,IN,FOLLOW_IN_in_in_predicate1023);
3140 stream_IN.add(IN98);
3141
3142 LPAR99=(Token)match(input,LPAR,FOLLOW_LPAR_in_in_predicate1025);
3143 stream_LPAR.add(LPAR99);
3144
3145 pushFollow(FOLLOW_in_value_list_in_in_predicate1027);
3146 in_value_list100=in_value_list();
3147
3148 state._fsp--;
3149
3150 stream_in_value_list.add(in_value_list100.getTree());
3151 RPAR101=(Token)match(input,RPAR,FOLLOW_RPAR_in_in_predicate1029);
3152 stream_RPAR.add(RPAR101);
3153
3154
3155
3156
3157
3158
3159
3160
3161
3162
3163 retval.tree = root_0;
3164 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
3165
3166 root_0 = (Object)adaptor.nil();
3167
3168 {
3169
3170 {
3171 Object root_1 = (Object)adaptor.nil();
3172 root_1 = (Object)adaptor.becomeRoot(stream_IN.nextNode(), root_1);
3173
3174 adaptor.addChild(root_1, stream_column_reference.nextTree());
3175 adaptor.addChild(root_1, stream_in_value_list.nextTree());
3176
3177 adaptor.addChild(root_0, root_1);
3178 }
3179
3180 }
3181
3182 retval.tree = root_0;
3183 }
3184 break;
3185 case 2 :
3186
3187 {
3188 pushFollow(FOLLOW_column_reference_in_in_predicate1055);
3189 column_reference102=column_reference();
3190
3191 state._fsp--;
3192
3193 stream_column_reference.add(column_reference102.getTree());
3194 NOT103=(Token)match(input,NOT,FOLLOW_NOT_in_in_predicate1057);
3195 stream_NOT.add(NOT103);
3196
3197 IN104=(Token)match(input,IN,FOLLOW_IN_in_in_predicate1059);
3198 stream_IN.add(IN104);
3199
3200 LPAR105=(Token)match(input,LPAR,FOLLOW_LPAR_in_in_predicate1061);
3201 stream_LPAR.add(LPAR105);
3202
3203 pushFollow(FOLLOW_in_value_list_in_in_predicate1063);
3204 in_value_list106=in_value_list();
3205
3206 state._fsp--;
3207
3208 stream_in_value_list.add(in_value_list106.getTree());
3209 RPAR107=(Token)match(input,RPAR,FOLLOW_RPAR_in_in_predicate1065);
3210 stream_RPAR.add(RPAR107);
3211
3212
3213
3214
3215
3216
3217
3218
3219
3220
3221 retval.tree = root_0;
3222 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
3223
3224 root_0 = (Object)adaptor.nil();
3225
3226 {
3227
3228 {
3229 Object root_1 = (Object)adaptor.nil();
3230 root_1 = (Object)adaptor.becomeRoot((Object)adaptor.create(NOT_IN, "NOT_IN"), root_1);
3231
3232 adaptor.addChild(root_1, stream_column_reference.nextTree());
3233 adaptor.addChild(root_1, stream_in_value_list.nextTree());
3234
3235 adaptor.addChild(root_0, root_1);
3236 }
3237
3238 }
3239
3240 retval.tree = root_0;
3241 }
3242 break;
3243
3244 }
3245 retval.stop = input.LT(-1);
3246
3247 retval.tree = (Object)adaptor.rulePostProcessing(root_0);
3248 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
3249
3250 }
3251 catch (RecognitionException re) {
3252 reportError(re);
3253 recover(input,re);
3254 retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
3255
3256 }
3257 finally {
3258 }
3259 return retval;
3260 }
3261
3262
3263 public static class in_value_list_return extends ParserRuleReturnScope {
3264 Object tree;
3265 public Object getTree() { return tree; }
3266 };
3267
3268
3269
3270 public final CmisQlStrictParser_CmisBaseGrammar.in_value_list_return in_value_list() throws RecognitionException {
3271 CmisQlStrictParser_CmisBaseGrammar.in_value_list_return retval = new CmisQlStrictParser_CmisBaseGrammar.in_value_list_return();
3272 retval.start = input.LT(1);
3273
3274 Object root_0 = null;
3275
3276 Token COMMA109=null;
3277 CmisQlStrictParser_CmisBaseGrammar.literal_return literal108 = null;
3278
3279 CmisQlStrictParser_CmisBaseGrammar.literal_return literal110 = null;
3280
3281
3282 Object COMMA109_tree=null;
3283 RewriteRuleTokenStream stream_COMMA=new RewriteRuleTokenStream(adaptor,"token COMMA");
3284 RewriteRuleSubtreeStream stream_literal=new RewriteRuleSubtreeStream(adaptor,"rule literal");
3285 try {
3286
3287
3288 {
3289 pushFollow(FOLLOW_literal_in_in_value_list1099);
3290 literal108=literal();
3291
3292 state._fsp--;
3293
3294 stream_literal.add(literal108.getTree());
3295
3296 loop25:
3297 do {
3298 int alt25=2;
3299 switch ( input.LA(1) ) {
3300 case COMMA:
3301 {
3302 alt25=1;
3303 }
3304 break;
3305
3306 }
3307
3308 switch (alt25) {
3309 case 1 :
3310
3311 {
3312 COMMA109=(Token)match(input,COMMA,FOLLOW_COMMA_in_in_value_list1103);
3313 stream_COMMA.add(COMMA109);
3314
3315 pushFollow(FOLLOW_literal_in_in_value_list1105);
3316 literal110=literal();
3317
3318 state._fsp--;
3319
3320 stream_literal.add(literal110.getTree());
3321
3322 }
3323 break;
3324
3325 default :
3326 break loop25;
3327 }
3328 } while (true);
3329
3330
3331
3332
3333
3334
3335
3336
3337
3338
3339 retval.tree = root_0;
3340 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
3341
3342 root_0 = (Object)adaptor.nil();
3343
3344 {
3345
3346 {
3347 Object root_1 = (Object)adaptor.nil();
3348 root_1 = (Object)adaptor.becomeRoot((Object)adaptor.create(IN_LIST, "IN_LIST"), root_1);
3349
3350 if ( !(stream_literal.hasNext()) ) {
3351 throw new RewriteEarlyExitException();
3352 }
3353 while ( stream_literal.hasNext() ) {
3354 adaptor.addChild(root_1, stream_literal.nextTree());
3355
3356 }
3357 stream_literal.reset();
3358
3359 adaptor.addChild(root_0, root_1);
3360 }
3361
3362 }
3363
3364 retval.tree = root_0;
3365 }
3366
3367 retval.stop = input.LT(-1);
3368
3369 retval.tree = (Object)adaptor.rulePostProcessing(root_0);
3370 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
3371
3372 }
3373 catch (RecognitionException re) {
3374 reportError(re);
3375 recover(input,re);
3376 retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
3377
3378 }
3379 finally {
3380 }
3381 return retval;
3382 }
3383
3384
3385 public static class like_predicate_return extends ParserRuleReturnScope {
3386 Object tree;
3387 public Object getTree() { return tree; }
3388 };
3389
3390
3391
3392 public final CmisQlStrictParser_CmisBaseGrammar.like_predicate_return like_predicate() throws RecognitionException {
3393 CmisQlStrictParser_CmisBaseGrammar.like_predicate_return retval = new CmisQlStrictParser_CmisBaseGrammar.like_predicate_return();
3394 retval.start = input.LT(1);
3395
3396 Object root_0 = null;
3397
3398 Token LIKE112=null;
3399 Token STRING_LIT113=null;
3400 Token NOT115=null;
3401 Token LIKE116=null;
3402 Token STRING_LIT117=null;
3403 CmisQlStrictParser_CmisBaseGrammar.column_reference_return column_reference111 = null;
3404
3405 CmisQlStrictParser_CmisBaseGrammar.column_reference_return column_reference114 = null;
3406
3407
3408 Object LIKE112_tree=null;
3409 Object STRING_LIT113_tree=null;
3410 Object NOT115_tree=null;
3411 Object LIKE116_tree=null;
3412 Object STRING_LIT117_tree=null;
3413 RewriteRuleTokenStream stream_NOT=new RewriteRuleTokenStream(adaptor,"token NOT");
3414 RewriteRuleTokenStream stream_STRING_LIT=new RewriteRuleTokenStream(adaptor,"token STRING_LIT");
3415 RewriteRuleTokenStream stream_LIKE=new RewriteRuleTokenStream(adaptor,"token LIKE");
3416 RewriteRuleSubtreeStream stream_column_reference=new RewriteRuleSubtreeStream(adaptor,"rule column_reference");
3417 try {
3418
3419 int alt26=2;
3420 switch ( input.LA(1) ) {
3421 case ID:
3422 {
3423 switch ( input.LA(2) ) {
3424 case DOT:
3425 {
3426 switch ( input.LA(3) ) {
3427 case ID:
3428 {
3429 switch ( input.LA(4) ) {
3430 case LIKE:
3431 {
3432 alt26=1;
3433 }
3434 break;
3435 case NOT:
3436 {
3437 alt26=2;
3438 }
3439 break;
3440 default:
3441 NoViableAltException nvae =
3442 new NoViableAltException("", 26, 5, input);
3443
3444 throw nvae;
3445 }
3446
3447 }
3448 break;
3449 default:
3450 NoViableAltException nvae =
3451 new NoViableAltException("", 26, 2, input);
3452
3453 throw nvae;
3454 }
3455
3456 }
3457 break;
3458 case LIKE:
3459 {
3460 alt26=1;
3461 }
3462 break;
3463 case NOT:
3464 {
3465 alt26=2;
3466 }
3467 break;
3468 default:
3469 NoViableAltException nvae =
3470 new NoViableAltException("", 26, 1, input);
3471
3472 throw nvae;
3473 }
3474
3475 }
3476 break;
3477 default:
3478 NoViableAltException nvae =
3479 new NoViableAltException("", 26, 0, input);
3480
3481 throw nvae;
3482 }
3483
3484 switch (alt26) {
3485 case 1 :
3486
3487 {
3488 pushFollow(FOLLOW_column_reference_in_like_predicate1141);
3489 column_reference111=column_reference();
3490
3491 state._fsp--;
3492
3493 stream_column_reference.add(column_reference111.getTree());
3494 LIKE112=(Token)match(input,LIKE,FOLLOW_LIKE_in_like_predicate1143);
3495 stream_LIKE.add(LIKE112);
3496
3497 STRING_LIT113=(Token)match(input,STRING_LIT,FOLLOW_STRING_LIT_in_like_predicate1145);
3498 stream_STRING_LIT.add(STRING_LIT113);
3499
3500
3501
3502
3503
3504
3505
3506
3507
3508
3509 retval.tree = root_0;
3510 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
3511
3512 root_0 = (Object)adaptor.nil();
3513
3514 {
3515
3516 {
3517 Object root_1 = (Object)adaptor.nil();
3518 root_1 = (Object)adaptor.becomeRoot(stream_LIKE.nextNode(), root_1);
3519
3520 adaptor.addChild(root_1, stream_column_reference.nextTree());
3521 adaptor.addChild(root_1, stream_STRING_LIT.nextNode());
3522
3523 adaptor.addChild(root_0, root_1);
3524 }
3525
3526 }
3527
3528 retval.tree = root_0;
3529 }
3530 break;
3531 case 2 :
3532
3533 {
3534 pushFollow(FOLLOW_column_reference_in_like_predicate1171);
3535 column_reference114=column_reference();
3536
3537 state._fsp--;
3538
3539 stream_column_reference.add(column_reference114.getTree());
3540 NOT115=(Token)match(input,NOT,FOLLOW_NOT_in_like_predicate1173);
3541 stream_NOT.add(NOT115);
3542
3543 LIKE116=(Token)match(input,LIKE,FOLLOW_LIKE_in_like_predicate1175);
3544 stream_LIKE.add(LIKE116);
3545
3546 STRING_LIT117=(Token)match(input,STRING_LIT,FOLLOW_STRING_LIT_in_like_predicate1177);
3547 stream_STRING_LIT.add(STRING_LIT117);
3548
3549
3550
3551
3552
3553
3554
3555
3556
3557
3558 retval.tree = root_0;
3559 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
3560
3561 root_0 = (Object)adaptor.nil();
3562
3563 {
3564
3565 {
3566 Object root_1 = (Object)adaptor.nil();
3567 root_1 = (Object)adaptor.becomeRoot((Object)adaptor.create(NOT_LIKE, "NOT_LIKE"), root_1);
3568
3569 adaptor.addChild(root_1, stream_column_reference.nextTree());
3570 adaptor.addChild(root_1, stream_STRING_LIT.nextNode());
3571
3572 adaptor.addChild(root_0, root_1);
3573 }
3574
3575 }
3576
3577 retval.tree = root_0;
3578 }
3579 break;
3580
3581 }
3582 retval.stop = input.LT(-1);
3583
3584 retval.tree = (Object)adaptor.rulePostProcessing(root_0);
3585 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
3586
3587 }
3588 catch (RecognitionException re) {
3589 reportError(re);
3590 recover(input,re);
3591 retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
3592
3593 }
3594 finally {
3595 }
3596 return retval;
3597 }
3598
3599
3600 public static class null_predicate_return extends ParserRuleReturnScope {
3601 Object tree;
3602 public Object getTree() { return tree; }
3603 };
3604
3605
3606
3607 public final CmisQlStrictParser_CmisBaseGrammar.null_predicate_return null_predicate() throws RecognitionException {
3608 CmisQlStrictParser_CmisBaseGrammar.null_predicate_return retval = new CmisQlStrictParser_CmisBaseGrammar.null_predicate_return();
3609 retval.start = input.LT(1);
3610
3611 Object root_0 = null;
3612
3613 Token IS119=null;
3614 Token NOT120=null;
3615 Token NULL121=null;
3616 Token NULL122=null;
3617 CmisQlStrictParser_CmisBaseGrammar.column_reference_return column_reference118 = null;
3618
3619
3620 Object IS119_tree=null;
3621 Object NOT120_tree=null;
3622 Object NULL121_tree=null;
3623 Object NULL122_tree=null;
3624 RewriteRuleTokenStream stream_NOT=new RewriteRuleTokenStream(adaptor,"token NOT");
3625 RewriteRuleTokenStream stream_IS=new RewriteRuleTokenStream(adaptor,"token IS");
3626 RewriteRuleTokenStream stream_NULL=new RewriteRuleTokenStream(adaptor,"token NULL");
3627 RewriteRuleSubtreeStream stream_column_reference=new RewriteRuleSubtreeStream(adaptor,"rule column_reference");
3628 try {
3629
3630
3631 {
3632 pushFollow(FOLLOW_column_reference_in_null_predicate1221);
3633 column_reference118=column_reference();
3634
3635 state._fsp--;
3636
3637 stream_column_reference.add(column_reference118.getTree());
3638 IS119=(Token)match(input,IS,FOLLOW_IS_in_null_predicate1223);
3639 stream_IS.add(IS119);
3640
3641
3642 int alt27=2;
3643 switch ( input.LA(1) ) {
3644 case NOT:
3645 {
3646 alt27=1;
3647 }
3648 break;
3649 case NULL:
3650 {
3651 alt27=2;
3652 }
3653 break;
3654 default:
3655 NoViableAltException nvae =
3656 new NoViableAltException("", 27, 0, input);
3657
3658 throw nvae;
3659 }
3660
3661 switch (alt27) {
3662 case 1 :
3663
3664 {
3665 NOT120=(Token)match(input,NOT,FOLLOW_NOT_in_null_predicate1233);
3666 stream_NOT.add(NOT120);
3667
3668 NULL121=(Token)match(input,NULL,FOLLOW_NULL_in_null_predicate1235);
3669 stream_NULL.add(NULL121);
3670
3671
3672
3673
3674
3675
3676
3677
3678
3679
3680 retval.tree = root_0;
3681 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
3682
3683 root_0 = (Object)adaptor.nil();
3684
3685 {
3686
3687 {
3688 Object root_1 = (Object)adaptor.nil();
3689 root_1 = (Object)adaptor.becomeRoot((Object)adaptor.create(IS_NOT_NULL, "IS_NOT_NULL"), root_1);
3690
3691 adaptor.addChild(root_1, stream_column_reference.nextTree());
3692
3693 adaptor.addChild(root_0, root_1);
3694 }
3695
3696 }
3697
3698 retval.tree = root_0;
3699 }
3700 break;
3701 case 2 :
3702
3703 {
3704 NULL122=(Token)match(input,NULL,FOLLOW_NULL_in_null_predicate1253);
3705 stream_NULL.add(NULL122);
3706
3707
3708
3709
3710
3711
3712
3713
3714
3715
3716 retval.tree = root_0;
3717 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
3718
3719 root_0 = (Object)adaptor.nil();
3720
3721 {
3722
3723 {
3724 Object root_1 = (Object)adaptor.nil();
3725 root_1 = (Object)adaptor.becomeRoot((Object)adaptor.create(IS_NULL, "IS_NULL"), root_1);
3726
3727 adaptor.addChild(root_1, stream_column_reference.nextTree());
3728
3729 adaptor.addChild(root_0, root_1);
3730 }
3731
3732 }
3733
3734 retval.tree = root_0;
3735 }
3736 break;
3737
3738 }
3739
3740
3741 }
3742
3743 retval.stop = input.LT(-1);
3744
3745 retval.tree = (Object)adaptor.rulePostProcessing(root_0);
3746 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
3747
3748 }
3749 catch (RecognitionException re) {
3750 reportError(re);
3751 recover(input,re);
3752 retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
3753
3754 }
3755 finally {
3756 }
3757 return retval;
3758 }
3759
3760
3761 public static class quantified_comparison_predicate_return extends ParserRuleReturnScope {
3762 Object tree;
3763 public Object getTree() { return tree; }
3764 };
3765
3766
3767
3768 public final CmisQlStrictParser_CmisBaseGrammar.quantified_comparison_predicate_return quantified_comparison_predicate() throws RecognitionException {
3769 CmisQlStrictParser_CmisBaseGrammar.quantified_comparison_predicate_return retval = new CmisQlStrictParser_CmisBaseGrammar.quantified_comparison_predicate_return();
3770 retval.start = input.LT(1);
3771
3772 Object root_0 = null;
3773
3774 Token EQ124=null;
3775 Token ANY125=null;
3776 CmisQlStrictParser_CmisBaseGrammar.literal_return literal123 = null;
3777
3778 CmisQlStrictParser_CmisBaseGrammar.multi_valued_column_reference_return multi_valued_column_reference126 = null;
3779
3780
3781 Object EQ124_tree=null;
3782 Object ANY125_tree=null;
3783 RewriteRuleTokenStream stream_ANY=new RewriteRuleTokenStream(adaptor,"token ANY");
3784 RewriteRuleTokenStream stream_EQ=new RewriteRuleTokenStream(adaptor,"token EQ");
3785 RewriteRuleSubtreeStream stream_multi_valued_column_reference=new RewriteRuleSubtreeStream(adaptor,"rule multi_valued_column_reference");
3786 RewriteRuleSubtreeStream stream_literal=new RewriteRuleSubtreeStream(adaptor,"rule literal");
3787 try {
3788
3789
3790 {
3791 pushFollow(FOLLOW_literal_in_quantified_comparison_predicate1293);
3792 literal123=literal();
3793
3794 state._fsp--;
3795
3796 stream_literal.add(literal123.getTree());
3797 EQ124=(Token)match(input,EQ,FOLLOW_EQ_in_quantified_comparison_predicate1295);
3798 stream_EQ.add(EQ124);
3799
3800 ANY125=(Token)match(input,ANY,FOLLOW_ANY_in_quantified_comparison_predicate1297);
3801 stream_ANY.add(ANY125);
3802
3803 pushFollow(FOLLOW_multi_valued_column_reference_in_quantified_comparison_predicate1299);
3804 multi_valued_column_reference126=multi_valued_column_reference();
3805
3806 state._fsp--;
3807
3808 stream_multi_valued_column_reference.add(multi_valued_column_reference126.getTree());
3809
3810
3811
3812
3813
3814
3815
3816
3817
3818 retval.tree = root_0;
3819 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
3820
3821 root_0 = (Object)adaptor.nil();
3822
3823 {
3824
3825 {
3826 Object root_1 = (Object)adaptor.nil();
3827 root_1 = (Object)adaptor.becomeRoot((Object)adaptor.create(EQ_ANY, "EQ_ANY"), root_1);
3828
3829 adaptor.addChild(root_1, stream_literal.nextTree());
3830 adaptor.addChild(root_1, stream_multi_valued_column_reference.nextTree());
3831
3832 adaptor.addChild(root_0, root_1);
3833 }
3834
3835 }
3836
3837 retval.tree = root_0;
3838 }
3839
3840 retval.stop = input.LT(-1);
3841
3842 retval.tree = (Object)adaptor.rulePostProcessing(root_0);
3843 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
3844
3845 }
3846 catch (RecognitionException re) {
3847 reportError(re);
3848 recover(input,re);
3849 retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
3850
3851 }
3852 finally {
3853 }
3854 return retval;
3855 }
3856
3857
3858 public static class quantified_in_predicate_return extends ParserRuleReturnScope {
3859 Object tree;
3860 public Object getTree() { return tree; }
3861 };
3862
3863
3864
3865 public final CmisQlStrictParser_CmisBaseGrammar.quantified_in_predicate_return quantified_in_predicate() throws RecognitionException {
3866 CmisQlStrictParser_CmisBaseGrammar.quantified_in_predicate_return retval = new CmisQlStrictParser_CmisBaseGrammar.quantified_in_predicate_return();
3867 retval.start = input.LT(1);
3868
3869 Object root_0 = null;
3870
3871 Token ANY127=null;
3872 Token NOT129=null;
3873 Token IN130=null;
3874 Token LPAR131=null;
3875 Token RPAR133=null;
3876 Token IN134=null;
3877 Token LPAR135=null;
3878 Token RPAR137=null;
3879 CmisQlStrictParser_CmisBaseGrammar.multi_valued_column_reference_return multi_valued_column_reference128 = null;
3880
3881 CmisQlStrictParser_CmisBaseGrammar.in_value_list_return in_value_list132 = null;
3882
3883 CmisQlStrictParser_CmisBaseGrammar.in_value_list_return in_value_list136 = null;
3884
3885
3886 Object ANY127_tree=null;
3887 Object NOT129_tree=null;
3888 Object IN130_tree=null;
3889 Object LPAR131_tree=null;
3890 Object RPAR133_tree=null;
3891 Object IN134_tree=null;
3892 Object LPAR135_tree=null;
3893 Object RPAR137_tree=null;
3894 RewriteRuleTokenStream stream_RPAR=new RewriteRuleTokenStream(adaptor,"token RPAR");
3895 RewriteRuleTokenStream stream_ANY=new RewriteRuleTokenStream(adaptor,"token ANY");
3896 RewriteRuleTokenStream stream_IN=new RewriteRuleTokenStream(adaptor,"token IN");
3897 RewriteRuleTokenStream stream_NOT=new RewriteRuleTokenStream(adaptor,"token NOT");
3898 RewriteRuleTokenStream stream_LPAR=new RewriteRuleTokenStream(adaptor,"token LPAR");
3899 RewriteRuleSubtreeStream stream_in_value_list=new RewriteRuleSubtreeStream(adaptor,"rule in_value_list");
3900 RewriteRuleSubtreeStream stream_multi_valued_column_reference=new RewriteRuleSubtreeStream(adaptor,"rule multi_valued_column_reference");
3901 try {
3902
3903
3904 {
3905 ANY127=(Token)match(input,ANY,FOLLOW_ANY_in_quantified_in_predicate1331);
3906 stream_ANY.add(ANY127);
3907
3908 pushFollow(FOLLOW_multi_valued_column_reference_in_quantified_in_predicate1333);
3909 multi_valued_column_reference128=multi_valued_column_reference();
3910
3911 state._fsp--;
3912
3913 stream_multi_valued_column_reference.add(multi_valued_column_reference128.getTree());
3914
3915 int alt28=2;
3916 switch ( input.LA(1) ) {
3917 case NOT:
3918 {
3919 alt28=1;
3920 }
3921 break;
3922 case IN:
3923 {
3924 alt28=2;
3925 }
3926 break;
3927 default:
3928 NoViableAltException nvae =
3929 new NoViableAltException("", 28, 0, input);
3930
3931 throw nvae;
3932 }
3933
3934 switch (alt28) {
3935 case 1 :
3936
3937 {
3938 NOT129=(Token)match(input,NOT,FOLLOW_NOT_in_quantified_in_predicate1343);
3939 stream_NOT.add(NOT129);
3940
3941 IN130=(Token)match(input,IN,FOLLOW_IN_in_quantified_in_predicate1345);
3942 stream_IN.add(IN130);
3943
3944 LPAR131=(Token)match(input,LPAR,FOLLOW_LPAR_in_quantified_in_predicate1347);
3945 stream_LPAR.add(LPAR131);
3946
3947 pushFollow(FOLLOW_in_value_list_in_quantified_in_predicate1349);
3948 in_value_list132=in_value_list();
3949
3950 state._fsp--;
3951
3952 stream_in_value_list.add(in_value_list132.getTree());
3953 RPAR133=(Token)match(input,RPAR,FOLLOW_RPAR_in_quantified_in_predicate1351);
3954 stream_RPAR.add(RPAR133);
3955
3956
3957
3958
3959
3960
3961
3962
3963
3964
3965 retval.tree = root_0;
3966 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
3967
3968 root_0 = (Object)adaptor.nil();
3969
3970 {
3971
3972 {
3973 Object root_1 = (Object)adaptor.nil();
3974 root_1 = (Object)adaptor.becomeRoot((Object)adaptor.create(NOT_IN_ANY, "NOT_IN_ANY"), root_1);
3975
3976 adaptor.addChild(root_1, stream_multi_valued_column_reference.nextTree());
3977 adaptor.addChild(root_1, stream_in_value_list.nextTree());
3978
3979 adaptor.addChild(root_0, root_1);
3980 }
3981
3982 }
3983
3984 retval.tree = root_0;
3985 }
3986 break;
3987 case 2 :
3988
3989 {
3990 IN134=(Token)match(input,IN,FOLLOW_IN_in_quantified_in_predicate1382);
3991 stream_IN.add(IN134);
3992
3993 LPAR135=(Token)match(input,LPAR,FOLLOW_LPAR_in_quantified_in_predicate1388);
3994 stream_LPAR.add(LPAR135);
3995
3996 pushFollow(FOLLOW_in_value_list_in_quantified_in_predicate1390);
3997 in_value_list136=in_value_list();
3998
3999 state._fsp--;
4000
4001 stream_in_value_list.add(in_value_list136.getTree());
4002 RPAR137=(Token)match(input,RPAR,FOLLOW_RPAR_in_quantified_in_predicate1392);
4003 stream_RPAR.add(RPAR137);
4004
4005
4006
4007
4008
4009
4010
4011
4012
4013
4014 retval.tree = root_0;
4015 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
4016
4017 root_0 = (Object)adaptor.nil();
4018
4019 {
4020
4021 {
4022 Object root_1 = (Object)adaptor.nil();
4023 root_1 = (Object)adaptor.becomeRoot((Object)adaptor.create(IN_ANY, "IN_ANY"), root_1);
4024
4025 adaptor.addChild(root_1, stream_multi_valued_column_reference.nextTree());
4026 adaptor.addChild(root_1, stream_in_value_list.nextTree());
4027
4028 adaptor.addChild(root_0, root_1);
4029 }
4030
4031 }
4032
4033 retval.tree = root_0;
4034 }
4035 break;
4036
4037 }
4038
4039
4040 }
4041
4042 retval.stop = input.LT(-1);
4043
4044 retval.tree = (Object)adaptor.rulePostProcessing(root_0);
4045 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
4046
4047 }
4048 catch (RecognitionException re) {
4049 reportError(re);
4050 recover(input,re);
4051 retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
4052
4053 }
4054 finally {
4055 }
4056 return retval;
4057 }
4058
4059
4060 public static class text_search_predicate_return extends ParserRuleReturnScope {
4061 Object tree;
4062 public Object getTree() { return tree; }
4063 };
4064
4065
4066
4067 public final CmisQlStrictParser_CmisBaseGrammar.text_search_predicate_return text_search_predicate() throws RecognitionException {
4068 CmisQlStrictParser_CmisBaseGrammar.text_search_predicate_return retval = new CmisQlStrictParser_CmisBaseGrammar.text_search_predicate_return();
4069 retval.start = input.LT(1);
4070
4071 Object root_0 = null;
4072
4073 Token CONTAINS138=null;
4074 Token LPAR139=null;
4075 Token COMMA141=null;
4076 Token RPAR143=null;
4077 CmisQlStrictParser_CmisBaseGrammar.qualifier_return qualifier140 = null;
4078
4079 CmisQlStrictParser_CmisBaseGrammar.text_search_expression_return text_search_expression142 = null;
4080
4081
4082 Object CONTAINS138_tree=null;
4083 Object LPAR139_tree=null;
4084 Object COMMA141_tree=null;
4085 Object RPAR143_tree=null;
4086 RewriteRuleTokenStream stream_RPAR=new RewriteRuleTokenStream(adaptor,"token RPAR");
4087 RewriteRuleTokenStream stream_LPAR=new RewriteRuleTokenStream(adaptor,"token LPAR");
4088 RewriteRuleTokenStream stream_COMMA=new RewriteRuleTokenStream(adaptor,"token COMMA");
4089 RewriteRuleTokenStream stream_CONTAINS=new RewriteRuleTokenStream(adaptor,"token CONTAINS");
4090 RewriteRuleSubtreeStream stream_text_search_expression=new RewriteRuleSubtreeStream(adaptor,"rule text_search_expression");
4091 RewriteRuleSubtreeStream stream_qualifier=new RewriteRuleSubtreeStream(adaptor,"rule qualifier");
4092 try {
4093
4094
4095 {
4096 CONTAINS138=(Token)match(input,CONTAINS,FOLLOW_CONTAINS_in_text_search_predicate1441);
4097 stream_CONTAINS.add(CONTAINS138);
4098
4099 LPAR139=(Token)match(input,LPAR,FOLLOW_LPAR_in_text_search_predicate1443);
4100 stream_LPAR.add(LPAR139);
4101
4102
4103 int alt29=2;
4104 switch ( input.LA(1) ) {
4105 case ID:
4106 {
4107 alt29=1;
4108 }
4109 break;
4110 }
4111
4112 switch (alt29) {
4113 case 1 :
4114
4115 {
4116 pushFollow(FOLLOW_qualifier_in_text_search_predicate1446);
4117 qualifier140=qualifier();
4118
4119 state._fsp--;
4120
4121 stream_qualifier.add(qualifier140.getTree());
4122 COMMA141=(Token)match(input,COMMA,FOLLOW_COMMA_in_text_search_predicate1448);
4123 stream_COMMA.add(COMMA141);
4124
4125
4126 }
4127 break;
4128
4129 }
4130
4131 pushFollow(FOLLOW_text_search_expression_in_text_search_predicate1452);
4132 text_search_expression142=text_search_expression();
4133
4134 state._fsp--;
4135
4136 stream_text_search_expression.add(text_search_expression142.getTree());
4137 RPAR143=(Token)match(input,RPAR,FOLLOW_RPAR_in_text_search_predicate1454);
4138 stream_RPAR.add(RPAR143);
4139
4140
4141
4142
4143
4144
4145
4146
4147
4148
4149 retval.tree = root_0;
4150 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
4151
4152 root_0 = (Object)adaptor.nil();
4153
4154 {
4155
4156 {
4157 Object root_1 = (Object)adaptor.nil();
4158 root_1 = (Object)adaptor.becomeRoot(stream_CONTAINS.nextNode(), root_1);
4159
4160
4161 if ( stream_qualifier.hasNext() ) {
4162 adaptor.addChild(root_1, stream_qualifier.nextTree());
4163
4164 }
4165 stream_qualifier.reset();
4166 adaptor.addChild(root_1, stream_text_search_expression.nextTree());
4167
4168 adaptor.addChild(root_0, root_1);
4169 }
4170
4171 }
4172
4173 retval.tree = root_0;
4174 }
4175
4176 retval.stop = input.LT(-1);
4177
4178 retval.tree = (Object)adaptor.rulePostProcessing(root_0);
4179 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
4180
4181 }
4182 catch (RecognitionException re) {
4183 reportError(re);
4184 recover(input,re);
4185 retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
4186
4187 }
4188 finally {
4189 }
4190 return retval;
4191 }
4192
4193
4194 public static class folder_predicate_return extends ParserRuleReturnScope {
4195 Object tree;
4196 public Object getTree() { return tree; }
4197 };
4198
4199
4200
4201 public final CmisQlStrictParser_CmisBaseGrammar.folder_predicate_return folder_predicate() throws RecognitionException {
4202 CmisQlStrictParser_CmisBaseGrammar.folder_predicate_return retval = new CmisQlStrictParser_CmisBaseGrammar.folder_predicate_return();
4203 retval.start = input.LT(1);
4204
4205 Object root_0 = null;
4206
4207 Token f=null;
4208 Token LPAR144=null;
4209 Token COMMA146=null;
4210 Token RPAR148=null;
4211 CmisQlStrictParser_CmisBaseGrammar.qualifier_return qualifier145 = null;
4212
4213 CmisQlStrictParser_CmisBaseGrammar.folder_id_return folder_id147 = null;
4214
4215
4216 Object f_tree=null;
4217 Object LPAR144_tree=null;
4218 Object COMMA146_tree=null;
4219 Object RPAR148_tree=null;
4220 RewriteRuleTokenStream stream_RPAR=new RewriteRuleTokenStream(adaptor,"token RPAR");
4221 RewriteRuleTokenStream stream_LPAR=new RewriteRuleTokenStream(adaptor,"token LPAR");
4222 RewriteRuleTokenStream stream_COMMA=new RewriteRuleTokenStream(adaptor,"token COMMA");
4223 RewriteRuleTokenStream stream_IN_TREE=new RewriteRuleTokenStream(adaptor,"token IN_TREE");
4224 RewriteRuleTokenStream stream_IN_FOLDER=new RewriteRuleTokenStream(adaptor,"token IN_FOLDER");
4225 RewriteRuleSubtreeStream stream_folder_id=new RewriteRuleSubtreeStream(adaptor,"rule folder_id");
4226 RewriteRuleSubtreeStream stream_qualifier=new RewriteRuleSubtreeStream(adaptor,"rule qualifier");
4227 try {
4228
4229
4230 {
4231
4232 int alt30=2;
4233 switch ( input.LA(1) ) {
4234 case IN_FOLDER:
4235 {
4236 alt30=1;
4237 }
4238 break;
4239 case IN_TREE:
4240 {
4241 alt30=2;
4242 }
4243 break;
4244 default:
4245 NoViableAltException nvae =
4246 new NoViableAltException("", 30, 0, input);
4247
4248 throw nvae;
4249 }
4250
4251 switch (alt30) {
4252 case 1 :
4253
4254 {
4255 f=(Token)match(input,IN_FOLDER,FOLLOW_IN_FOLDER_in_folder_predicate1497);
4256 stream_IN_FOLDER.add(f);
4257
4258
4259 }
4260 break;
4261 case 2 :
4262
4263 {
4264 f=(Token)match(input,IN_TREE,FOLLOW_IN_TREE_in_folder_predicate1503);
4265 stream_IN_TREE.add(f);
4266
4267
4268 }
4269 break;
4270
4271 }
4272
4273 LPAR144=(Token)match(input,LPAR,FOLLOW_LPAR_in_folder_predicate1507);
4274 stream_LPAR.add(LPAR144);
4275
4276
4277 int alt31=2;
4278 switch ( input.LA(1) ) {
4279 case ID:
4280 {
4281 alt31=1;
4282 }
4283 break;
4284 }
4285
4286 switch (alt31) {
4287 case 1 :
4288
4289 {
4290 pushFollow(FOLLOW_qualifier_in_folder_predicate1510);
4291 qualifier145=qualifier();
4292
4293 state._fsp--;
4294
4295 stream_qualifier.add(qualifier145.getTree());
4296 COMMA146=(Token)match(input,COMMA,FOLLOW_COMMA_in_folder_predicate1512);
4297 stream_COMMA.add(COMMA146);
4298
4299
4300 }
4301 break;
4302
4303 }
4304
4305 pushFollow(FOLLOW_folder_id_in_folder_predicate1516);
4306 folder_id147=folder_id();
4307
4308 state._fsp--;
4309
4310 stream_folder_id.add(folder_id147.getTree());
4311 RPAR148=(Token)match(input,RPAR,FOLLOW_RPAR_in_folder_predicate1518);
4312 stream_RPAR.add(RPAR148);
4313
4314
4315
4316
4317
4318
4319
4320
4321
4322
4323 retval.tree = root_0;
4324 RewriteRuleTokenStream stream_f=new RewriteRuleTokenStream(adaptor,"token f",f);
4325 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
4326
4327 root_0 = (Object)adaptor.nil();
4328
4329 {
4330
4331 {
4332 Object root_1 = (Object)adaptor.nil();
4333 root_1 = (Object)adaptor.becomeRoot(stream_f.nextNode(), root_1);
4334
4335
4336 if ( stream_qualifier.hasNext() ) {
4337 adaptor.addChild(root_1, stream_qualifier.nextTree());
4338
4339 }
4340 stream_qualifier.reset();
4341 adaptor.addChild(root_1, stream_folder_id.nextTree());
4342
4343 adaptor.addChild(root_0, root_1);
4344 }
4345
4346 }
4347
4348 retval.tree = root_0;
4349 }
4350
4351 retval.stop = input.LT(-1);
4352
4353 retval.tree = (Object)adaptor.rulePostProcessing(root_0);
4354 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
4355
4356 }
4357 catch (RecognitionException re) {
4358 reportError(re);
4359 recover(input,re);
4360 retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
4361
4362 }
4363 finally {
4364 }
4365 return retval;
4366 }
4367
4368
4369 public static class order_by_clause_return extends ParserRuleReturnScope {
4370 Object tree;
4371 public Object getTree() { return tree; }
4372 };
4373
4374
4375
4376 public final CmisQlStrictParser_CmisBaseGrammar.order_by_clause_return order_by_clause() throws RecognitionException {
4377 CmisQlStrictParser_CmisBaseGrammar.order_by_clause_return retval = new CmisQlStrictParser_CmisBaseGrammar.order_by_clause_return();
4378 retval.start = input.LT(1);
4379
4380 Object root_0 = null;
4381
4382 Token ORDER149=null;
4383 Token BY150=null;
4384 Token COMMA152=null;
4385 CmisQlStrictParser_CmisBaseGrammar.sort_specification_return sort_specification151 = null;
4386
4387 CmisQlStrictParser_CmisBaseGrammar.sort_specification_return sort_specification153 = null;
4388
4389
4390 Object ORDER149_tree=null;
4391 Object BY150_tree=null;
4392 Object COMMA152_tree=null;
4393 RewriteRuleTokenStream stream_BY=new RewriteRuleTokenStream(adaptor,"token BY");
4394 RewriteRuleTokenStream stream_ORDER=new RewriteRuleTokenStream(adaptor,"token ORDER");
4395 RewriteRuleTokenStream stream_COMMA=new RewriteRuleTokenStream(adaptor,"token COMMA");
4396 RewriteRuleSubtreeStream stream_sort_specification=new RewriteRuleSubtreeStream(adaptor,"rule sort_specification");
4397 try {
4398
4399
4400 {
4401 ORDER149=(Token)match(input,ORDER,FOLLOW_ORDER_in_order_by_clause1552);
4402 stream_ORDER.add(ORDER149);
4403
4404 BY150=(Token)match(input,BY,FOLLOW_BY_in_order_by_clause1554);
4405 stream_BY.add(BY150);
4406
4407 pushFollow(FOLLOW_sort_specification_in_order_by_clause1556);
4408 sort_specification151=sort_specification();
4409
4410 state._fsp--;
4411
4412 stream_sort_specification.add(sort_specification151.getTree());
4413
4414 loop32:
4415 do {
4416 int alt32=2;
4417 switch ( input.LA(1) ) {
4418 case COMMA:
4419 {
4420 alt32=1;
4421 }
4422 break;
4423
4424 }
4425
4426 switch (alt32) {
4427 case 1 :
4428
4429 {
4430 COMMA152=(Token)match(input,COMMA,FOLLOW_COMMA_in_order_by_clause1560);
4431 stream_COMMA.add(COMMA152);
4432
4433 pushFollow(FOLLOW_sort_specification_in_order_by_clause1562);
4434 sort_specification153=sort_specification();
4435
4436 state._fsp--;
4437
4438 stream_sort_specification.add(sort_specification153.getTree());
4439
4440 }
4441 break;
4442
4443 default :
4444 break loop32;
4445 }
4446 } while (true);
4447
4448
4449
4450
4451
4452
4453
4454
4455
4456
4457 retval.tree = root_0;
4458 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
4459
4460 root_0 = (Object)adaptor.nil();
4461
4462 {
4463
4464 {
4465 Object root_1 = (Object)adaptor.nil();
4466 root_1 = (Object)adaptor.becomeRoot((Object)adaptor.create(ORDER_BY, "ORDER_BY"), root_1);
4467
4468 if ( !(stream_sort_specification.hasNext()) ) {
4469 throw new RewriteEarlyExitException();
4470 }
4471 while ( stream_sort_specification.hasNext() ) {
4472 adaptor.addChild(root_1, stream_sort_specification.nextTree());
4473
4474 }
4475 stream_sort_specification.reset();
4476
4477 adaptor.addChild(root_0, root_1);
4478 }
4479
4480 }
4481
4482 retval.tree = root_0;
4483 }
4484
4485 retval.stop = input.LT(-1);
4486
4487 retval.tree = (Object)adaptor.rulePostProcessing(root_0);
4488 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
4489
4490 }
4491 catch (RecognitionException re) {
4492 reportError(re);
4493 recover(input,re);
4494 retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
4495
4496 }
4497 finally {
4498 }
4499 return retval;
4500 }
4501
4502
4503 public static class sort_specification_return extends ParserRuleReturnScope {
4504 Object tree;
4505 public Object getTree() { return tree; }
4506 };
4507
4508
4509
4510 public final CmisQlStrictParser_CmisBaseGrammar.sort_specification_return sort_specification() throws RecognitionException {
4511 CmisQlStrictParser_CmisBaseGrammar.sort_specification_return retval = new CmisQlStrictParser_CmisBaseGrammar.sort_specification_return();
4512 retval.start = input.LT(1);
4513
4514 Object root_0 = null;
4515
4516 Token set156=null;
4517 CmisQlStrictParser_CmisBaseGrammar.column_reference_return column_reference154 = null;
4518
4519 CmisQlStrictParser_CmisBaseGrammar.column_reference_return column_reference155 = null;
4520
4521
4522 Object set156_tree=null;
4523 RewriteRuleSubtreeStream stream_column_reference=new RewriteRuleSubtreeStream(adaptor,"rule column_reference");
4524 try {
4525
4526 int alt33=2;
4527 switch ( input.LA(1) ) {
4528 case ID:
4529 {
4530 switch ( input.LA(2) ) {
4531 case DOT:
4532 {
4533 switch ( input.LA(3) ) {
4534 case ID:
4535 {
4536 switch ( input.LA(4) ) {
4537 case EOF:
4538 case COMMA:
4539 {
4540 alt33=1;
4541 }
4542 break;
4543 case ASC:
4544 case DESC:
4545 {
4546 alt33=2;
4547 }
4548 break;
4549 default:
4550 NoViableAltException nvae =
4551 new NoViableAltException("", 33, 5, input);
4552
4553 throw nvae;
4554 }
4555
4556 }
4557 break;
4558 default:
4559 NoViableAltException nvae =
4560 new NoViableAltException("", 33, 2, input);
4561
4562 throw nvae;
4563 }
4564
4565 }
4566 break;
4567 case EOF:
4568 case COMMA:
4569 {
4570 alt33=1;
4571 }
4572 break;
4573 case ASC:
4574 case DESC:
4575 {
4576 alt33=2;
4577 }
4578 break;
4579 default:
4580 NoViableAltException nvae =
4581 new NoViableAltException("", 33, 1, input);
4582
4583 throw nvae;
4584 }
4585
4586 }
4587 break;
4588 default:
4589 NoViableAltException nvae =
4590 new NoViableAltException("", 33, 0, input);
4591
4592 throw nvae;
4593 }
4594
4595 switch (alt33) {
4596 case 1 :
4597
4598 {
4599 pushFollow(FOLLOW_column_reference_in_sort_specification1598);
4600 column_reference154=column_reference();
4601
4602 state._fsp--;
4603
4604 stream_column_reference.add(column_reference154.getTree());
4605
4606
4607
4608
4609
4610
4611
4612
4613
4614 retval.tree = root_0;
4615 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
4616
4617 root_0 = (Object)adaptor.nil();
4618
4619 {
4620 adaptor.addChild(root_0, stream_column_reference.nextTree());
4621 adaptor.addChild(root_0, (Object)adaptor.create(ASC, "ASC"));
4622
4623 }
4624
4625 retval.tree = root_0;
4626 }
4627 break;
4628 case 2 :
4629
4630 {
4631 root_0 = (Object)adaptor.nil();
4632
4633 pushFollow(FOLLOW_column_reference_in_sort_specification1612);
4634 column_reference155=column_reference();
4635
4636 state._fsp--;
4637
4638 adaptor.addChild(root_0, column_reference155.getTree());
4639 set156=(Token)input.LT(1);
4640 if ( (input.LA(1)>=ASC && input.LA(1)<=DESC) ) {
4641 input.consume();
4642 adaptor.addChild(root_0, (Object)adaptor.create(set156));
4643 state.errorRecovery=false;
4644 }
4645 else {
4646 MismatchedSetException mse = new MismatchedSetException(null,input);
4647 throw mse;
4648 }
4649
4650
4651 }
4652 break;
4653
4654 }
4655 retval.stop = input.LT(-1);
4656
4657 retval.tree = (Object)adaptor.rulePostProcessing(root_0);
4658 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
4659
4660 }
4661 catch (RecognitionException re) {
4662 reportError(re);
4663 recover(input,re);
4664 retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
4665
4666 }
4667 finally {
4668 }
4669 return retval;
4670 }
4671
4672
4673 public static class correlation_name_return extends ParserRuleReturnScope {
4674 Object tree;
4675 public Object getTree() { return tree; }
4676 };
4677
4678
4679
4680 public final CmisQlStrictParser_CmisBaseGrammar.correlation_name_return correlation_name() throws RecognitionException {
4681 CmisQlStrictParser_CmisBaseGrammar.correlation_name_return retval = new CmisQlStrictParser_CmisBaseGrammar.correlation_name_return();
4682 retval.start = input.LT(1);
4683
4684 Object root_0 = null;
4685
4686 Token ID157=null;
4687
4688 Object ID157_tree=null;
4689
4690 try {
4691
4692
4693 {
4694 root_0 = (Object)adaptor.nil();
4695
4696 ID157=(Token)match(input,ID,FOLLOW_ID_in_correlation_name1638);
4697 ID157_tree = (Object)adaptor.create(ID157);
4698 adaptor.addChild(root_0, ID157_tree);
4699
4700
4701 }
4702
4703 retval.stop = input.LT(-1);
4704
4705 retval.tree = (Object)adaptor.rulePostProcessing(root_0);
4706 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
4707
4708 }
4709 catch (RecognitionException re) {
4710 reportError(re);
4711 recover(input,re);
4712 retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
4713
4714 }
4715 finally {
4716 }
4717 return retval;
4718 }
4719
4720
4721 public static class table_name_return extends ParserRuleReturnScope {
4722 Object tree;
4723 public Object getTree() { return tree; }
4724 };
4725
4726
4727
4728 public final CmisQlStrictParser_CmisBaseGrammar.table_name_return table_name() throws RecognitionException {
4729 CmisQlStrictParser_CmisBaseGrammar.table_name_return retval = new CmisQlStrictParser_CmisBaseGrammar.table_name_return();
4730 retval.start = input.LT(1);
4731
4732 Object root_0 = null;
4733
4734 Token ID158=null;
4735
4736 Object ID158_tree=null;
4737
4738 try {
4739
4740
4741 {
4742 root_0 = (Object)adaptor.nil();
4743
4744 ID158=(Token)match(input,ID,FOLLOW_ID_in_table_name1649);
4745 ID158_tree = (Object)adaptor.create(ID158);
4746 adaptor.addChild(root_0, ID158_tree);
4747
4748
4749 }
4750
4751 retval.stop = input.LT(-1);
4752
4753 retval.tree = (Object)adaptor.rulePostProcessing(root_0);
4754 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
4755
4756 }
4757 catch (RecognitionException re) {
4758 reportError(re);
4759 recover(input,re);
4760 retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
4761
4762 }
4763 finally {
4764 }
4765 return retval;
4766 }
4767
4768
4769 public static class column_name_return extends ParserRuleReturnScope {
4770 Object tree;
4771 public Object getTree() { return tree; }
4772 };
4773
4774
4775
4776 public final CmisQlStrictParser_CmisBaseGrammar.column_name_return column_name() throws RecognitionException {
4777 CmisQlStrictParser_CmisBaseGrammar.column_name_return retval = new CmisQlStrictParser_CmisBaseGrammar.column_name_return();
4778 retval.start = input.LT(1);
4779
4780 Object root_0 = null;
4781
4782 Token ID159=null;
4783
4784 Object ID159_tree=null;
4785
4786 try {
4787
4788
4789 {
4790 root_0 = (Object)adaptor.nil();
4791
4792 ID159=(Token)match(input,ID,FOLLOW_ID_in_column_name1660);
4793 ID159_tree = (Object)adaptor.create(ID159);
4794 adaptor.addChild(root_0, ID159_tree);
4795
4796
4797 }
4798
4799 retval.stop = input.LT(-1);
4800
4801 retval.tree = (Object)adaptor.rulePostProcessing(root_0);
4802 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
4803
4804 }
4805 catch (RecognitionException re) {
4806 reportError(re);
4807 recover(input,re);
4808 retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
4809
4810 }
4811 finally {
4812 }
4813 return retval;
4814 }
4815
4816
4817 public static class multi_valued_column_name_return extends ParserRuleReturnScope {
4818 Object tree;
4819 public Object getTree() { return tree; }
4820 };
4821
4822
4823
4824 public final CmisQlStrictParser_CmisBaseGrammar.multi_valued_column_name_return multi_valued_column_name() throws RecognitionException {
4825 CmisQlStrictParser_CmisBaseGrammar.multi_valued_column_name_return retval = new CmisQlStrictParser_CmisBaseGrammar.multi_valued_column_name_return();
4826 retval.start = input.LT(1);
4827
4828 Object root_0 = null;
4829
4830 Token ID160=null;
4831
4832 Object ID160_tree=null;
4833
4834 try {
4835
4836
4837 {
4838 root_0 = (Object)adaptor.nil();
4839
4840 ID160=(Token)match(input,ID,FOLLOW_ID_in_multi_valued_column_name1671);
4841 ID160_tree = (Object)adaptor.create(ID160);
4842 adaptor.addChild(root_0, ID160_tree);
4843
4844
4845 }
4846
4847 retval.stop = input.LT(-1);
4848
4849 retval.tree = (Object)adaptor.rulePostProcessing(root_0);
4850 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
4851
4852 }
4853 catch (RecognitionException re) {
4854 reportError(re);
4855 recover(input,re);
4856 retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
4857
4858 }
4859 finally {
4860 }
4861 return retval;
4862 }
4863
4864
4865 public static class folder_id_return extends ParserRuleReturnScope {
4866 Object tree;
4867 public Object getTree() { return tree; }
4868 };
4869
4870
4871
4872 public final CmisQlStrictParser_CmisBaseGrammar.folder_id_return folder_id() throws RecognitionException {
4873 CmisQlStrictParser_CmisBaseGrammar.folder_id_return retval = new CmisQlStrictParser_CmisBaseGrammar.folder_id_return();
4874 retval.start = input.LT(1);
4875
4876 Object root_0 = null;
4877
4878 Token STRING_LIT161=null;
4879
4880 Object STRING_LIT161_tree=null;
4881
4882 try {
4883
4884
4885 {
4886 root_0 = (Object)adaptor.nil();
4887
4888 STRING_LIT161=(Token)match(input,STRING_LIT,FOLLOW_STRING_LIT_in_folder_id1682);
4889 STRING_LIT161_tree = (Object)adaptor.create(STRING_LIT161);
4890 adaptor.addChild(root_0, STRING_LIT161_tree);
4891
4892
4893 }
4894
4895 retval.stop = input.LT(-1);
4896
4897 retval.tree = (Object)adaptor.rulePostProcessing(root_0);
4898 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
4899
4900 }
4901 catch (RecognitionException re) {
4902 reportError(re);
4903 recover(input,re);
4904 retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
4905
4906 }
4907 finally {
4908 }
4909 return retval;
4910 }
4911
4912
4913 public static class text_search_expression_return extends ParserRuleReturnScope {
4914 Object tree;
4915 public Object getTree() { return tree; }
4916 };
4917
4918
4919
4920 public final CmisQlStrictParser_CmisBaseGrammar.text_search_expression_return text_search_expression() throws RecognitionException {
4921 CmisQlStrictParser_CmisBaseGrammar.text_search_expression_return retval = new CmisQlStrictParser_CmisBaseGrammar.text_search_expression_return();
4922 retval.start = input.LT(1);
4923
4924 Object root_0 = null;
4925
4926 Token STRING_LIT162=null;
4927
4928 Object STRING_LIT162_tree=null;
4929
4930 try {
4931
4932
4933 {
4934 root_0 = (Object)adaptor.nil();
4935
4936 STRING_LIT162=(Token)match(input,STRING_LIT,FOLLOW_STRING_LIT_in_text_search_expression1693);
4937 STRING_LIT162_tree = (Object)adaptor.create(STRING_LIT162);
4938 adaptor.addChild(root_0, STRING_LIT162_tree);
4939
4940
4941 }
4942
4943 retval.stop = input.LT(-1);
4944
4945 retval.tree = (Object)adaptor.rulePostProcessing(root_0);
4946 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
4947
4948 }
4949 catch (RecognitionException re) {
4950 reportError(re);
4951 recover(input,re);
4952 retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
4953
4954 }
4955 finally {
4956 }
4957 return retval;
4958 }
4959
4960
4961
4962
4963
4964 protected DFA22 dfa22 = new DFA22(this);
4965 protected DFA23 dfa23 = new DFA23(this);
4966 static final String DFA22_eotS =
4967 "\15\uffff";
4968 static final String DFA22_eofS =
4969 "\15\uffff";
4970 static final String DFA22_minS =
4971 "\1\45\1\36\5\uffff\1\104\1\uffff\1\43\2\uffff\1\36";
4972 static final String DFA22_maxS =
4973 "\1\104\1\65\5\uffff\1\104\1\uffff\1\44\2\uffff\1\65";
4974 static final String DFA22_acceptS =
4975 "\2\uffff\1\1\1\5\1\6\1\7\1\10\1\uffff\1\2\1\uffff\1\3\1\4\1\uffff";
4976 static final String DFA22_specialS =
4977 "\15\uffff}>";
4978 static final String[] DFA22_transitionS = {
4979 "\1\4\1\5\1\2\2\6\14\uffff\1\3\4\uffff\1\3\5\uffff\1\3\1\uffff"+
4980 "\1\3\1\1",
4981 "\1\13\3\uffff\1\11\1\10\1\12\12\uffff\1\7\6\2",
4982 "",
4983 "",
4984 "",
4985 "",
4986 "",
4987 "\1\14",
4988 "",
4989 "\1\10\1\12",
4990 "",
4991 "",
4992 "\1\13\3\uffff\1\11\1\10\1\12\13\uffff\6\2"
4993 };
4994
4995 static final short[] DFA22_eot = DFA.unpackEncodedString(DFA22_eotS);
4996 static final short[] DFA22_eof = DFA.unpackEncodedString(DFA22_eofS);
4997 static final char[] DFA22_min = DFA.unpackEncodedStringToUnsignedChars(DFA22_minS);
4998 static final char[] DFA22_max = DFA.unpackEncodedStringToUnsignedChars(DFA22_maxS);
4999 static final short[] DFA22_accept = DFA.unpackEncodedString(DFA22_acceptS);
5000 static final short[] DFA22_special = DFA.unpackEncodedString(DFA22_specialS);
5001 static final short[][] DFA22_transition;
5002
5003 static {
5004 int numStates = DFA22_transitionS.length;
5005 DFA22_transition = new short[numStates][];
5006 for (int i=0; i<numStates; i++) {
5007 DFA22_transition[i] = DFA.unpackEncodedString(DFA22_transitionS[i]);
5008 }
5009 }
5010
5011 class DFA22 extends DFA {
5012
5013 public DFA22(BaseRecognizer recognizer) {
5014 this.recognizer = recognizer;
5015 this.decisionNumber = 22;
5016 this.eot = DFA22_eot;
5017 this.eof = DFA22_eof;
5018 this.min = DFA22_min;
5019 this.max = DFA22_max;
5020 this.accept = DFA22_accept;
5021 this.special = DFA22_special;
5022 this.transition = DFA22_transition;
5023 }
5024 public String getDescription() {
5025 return "157:1: predicate : ( comparison_predicate | in_predicate | like_predicate | null_predicate | quantified_comparison_predicate | quantified_in_predicate | text_search_predicate | folder_predicate );";
5026 }
5027 }
5028 static final String DFA23_eotS =
5029 "\15\uffff";
5030 static final String DFA23_eofS =
5031 "\15\uffff";
5032 static final String DFA23_minS =
5033 "\1\47\1\57\1\54\1\104\6\uffff\1\55\2\60";
5034 static final String DFA23_maxS =
5035 "\1\104\1\65\1\54\1\104\6\uffff\1\55\2\65";
5036 static final String DFA23_acceptS =
5037 "\4\uffff\1\1\1\2\1\3\1\4\1\5\1\6\3\uffff";
5038 static final String DFA23_specialS =
5039 "\15\uffff}>";
5040 static final String[] DFA23_transitionS = {
5041 "\1\2\34\uffff\1\1",
5042 "\1\3\1\4\1\5\1\6\1\7\1\10\1\11",
5043 "\1\12",
5044 "\1\13",
5045 "",
5046 "",
5047 "",
5048 "",
5049 "",
5050 "",
5051 "\1\14",
5052 "\1\4\1\5\1\6\1\7\1\10\1\11",
5053 "\1\4\1\5\1\6\1\7\1\10\1\11"
5054 };
5055
5056 static final short[] DFA23_eot = DFA.unpackEncodedString(DFA23_eotS);
5057 static final short[] DFA23_eof = DFA.unpackEncodedString(DFA23_eofS);
5058 static final char[] DFA23_min = DFA.unpackEncodedStringToUnsignedChars(DFA23_minS);
5059 static final char[] DFA23_max = DFA.unpackEncodedStringToUnsignedChars(DFA23_maxS);
5060 static final short[] DFA23_accept = DFA.unpackEncodedString(DFA23_acceptS);
5061 static final short[] DFA23_special = DFA.unpackEncodedString(DFA23_specialS);
5062 static final short[][] DFA23_transition;
5063
5064 static {
5065 int numStates = DFA23_transitionS.length;
5066 DFA23_transition = new short[numStates][];
5067 for (int i=0; i<numStates; i++) {
5068 DFA23_transition[i] = DFA.unpackEncodedString(DFA23_transitionS[i]);
5069 }
5070 }
5071
5072 class DFA23 extends DFA {
5073
5074 public DFA23(BaseRecognizer recognizer) {
5075 this.recognizer = recognizer;
5076 this.decisionNumber = 23;
5077 this.eot = DFA23_eot;
5078 this.eof = DFA23_eof;
5079 this.min = DFA23_min;
5080 this.max = DFA23_max;
5081 this.accept = DFA23_accept;
5082 this.special = DFA23_special;
5083 this.transition = DFA23_transition;
5084 }
5085 public String getDescription() {
5086 return "168:1: comparison_predicate : ( value_expression EQ literal -> ^( EQ value_expression literal ) | value_expression NEQ literal -> ^( NEQ value_expression literal ) | value_expression LT literal -> ^( LT value_expression literal ) | value_expression GT literal -> ^( GT value_expression literal ) | value_expression LTEQ literal -> ^( LTEQ value_expression literal ) | value_expression GTEQ literal -> ^( GTEQ value_expression literal ) );";
5087 }
5088 }
5089
5090
5091 public static final BitSet FOLLOW_SELECT_in_query57 = new BitSet(new long[]{0x0000088000000000L,0x0000000000000010L});
5092 public static final BitSet FOLLOW_select_list_in_query59 = new BitSet(new long[]{0x0000000000020000L});
5093 public static final BitSet FOLLOW_from_clause_in_query61 = new BitSet(new long[]{0x0000000006000002L});
5094 public static final BitSet FOLLOW_where_clause_in_query63 = new BitSet(new long[]{0x0000000004000002L});
5095 public static final BitSet FOLLOW_order_by_clause_in_query66 = new BitSet(new long[]{0x0000000000000002L});
5096 public static final BitSet FOLLOW_STAR_in_select_list99 = new BitSet(new long[]{0x0000000000000002L});
5097 public static final BitSet FOLLOW_select_sublist_in_select_list107 = new BitSet(new long[]{0x0000400000000002L});
5098 public static final BitSet FOLLOW_COMMA_in_select_list111 = new BitSet(new long[]{0x0000088000000000L,0x0000000000000010L});
5099 public static final BitSet FOLLOW_select_sublist_in_select_list113 = new BitSet(new long[]{0x0000400000000002L});
5100 public static final BitSet FOLLOW_value_expression_in_select_sublist148 = new BitSet(new long[]{0x0000000000040002L,0x0000000000000010L});
5101 public static final BitSet FOLLOW_AS_in_select_sublist152 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000010L});
5102 public static final BitSet FOLLOW_column_name_in_select_sublist156 = new BitSet(new long[]{0x0000000000000002L});
5103 public static final BitSet FOLLOW_qualifier_in_select_sublist167 = new BitSet(new long[]{0x0000800000000000L});
5104 public static final BitSet FOLLOW_DOT_in_select_sublist169 = new BitSet(new long[]{0x0000080000000000L});
5105 public static final BitSet FOLLOW_STAR_in_select_sublist171 = new BitSet(new long[]{0x0000000000000002L});
5106 public static final BitSet FOLLOW_column_reference_in_value_expression194 = new BitSet(new long[]{0x0000000000000002L});
5107 public static final BitSet FOLLOW_numeric_value_function_in_value_expression202 = new BitSet(new long[]{0x0000000000000002L});
5108 public static final BitSet FOLLOW_qualifier_in_column_reference220 = new BitSet(new long[]{0x0000800000000000L});
5109 public static final BitSet FOLLOW_DOT_in_column_reference222 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000010L});
5110 public static final BitSet FOLLOW_column_name_in_column_reference227 = new BitSet(new long[]{0x0000000000000002L});
5111 public static final BitSet FOLLOW_qualifier_in_multi_valued_column_reference262 = new BitSet(new long[]{0x0000800000000000L});
5112 public static final BitSet FOLLOW_DOT_in_multi_valued_column_reference264 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000010L});
5113 public static final BitSet FOLLOW_multi_valued_column_name_in_multi_valued_column_reference269 = new BitSet(new long[]{0x0000000000000002L});
5114 public static final BitSet FOLLOW_SCORE_in_numeric_value_function302 = new BitSet(new long[]{0x0000100000000000L});
5115 public static final BitSet FOLLOW_LPAR_in_numeric_value_function304 = new BitSet(new long[]{0x0000200000000000L});
5116 public static final BitSet FOLLOW_RPAR_in_numeric_value_function306 = new BitSet(new long[]{0x0000000000000002L});
5117 public static final BitSet FOLLOW_table_name_in_qualifier325 = new BitSet(new long[]{0x0000000000000002L});
5118 public static final BitSet FOLLOW_FROM_in_from_clause342 = new BitSet(new long[]{0x0000100000000000L,0x0000000000000010L});
5119 public static final BitSet FOLLOW_table_reference_in_from_clause345 = new BitSet(new long[]{0x0000000000000002L});
5120 public static final BitSet FOLLOW_one_table_in_table_reference356 = new BitSet(new long[]{0x0000000000D80002L});
5121 public static final BitSet FOLLOW_table_join_in_table_reference358 = new BitSet(new long[]{0x0000000000D80002L});
5122 public static final BitSet FOLLOW_join_kind_in_table_join375 = new BitSet(new long[]{0x0000100000000000L,0x0000000000000010L});
5123 public static final BitSet FOLLOW_one_table_in_table_join377 = new BitSet(new long[]{0x0000000001000002L});
5124 public static final BitSet FOLLOW_join_specification_in_table_join379 = new BitSet(new long[]{0x0000000000000002L});
5125 public static final BitSet FOLLOW_LPAR_in_one_table415 = new BitSet(new long[]{0x0000100000000000L,0x0000000000000010L});
5126 public static final BitSet FOLLOW_table_reference_in_one_table418 = new BitSet(new long[]{0x0000200000000000L});
5127 public static final BitSet FOLLOW_RPAR_in_one_table420 = new BitSet(new long[]{0x0000000000000002L});
5128 public static final BitSet FOLLOW_table_name_in_one_table429 = new BitSet(new long[]{0x0000000000000002L});
5129 public static final BitSet FOLLOW_table_name_in_one_table453 = new BitSet(new long[]{0x0000000000040000L,0x0000000000000010L});
5130 public static final BitSet FOLLOW_AS_in_one_table455 = new BitSet(new long[]{0x0000000000040000L,0x0000000000000010L});
5131 public static final BitSet FOLLOW_correlation_name_in_one_table458 = new BitSet(new long[]{0x0000000000000002L});
5132 public static final BitSet FOLLOW_JOIN_in_join_kind494 = new BitSet(new long[]{0x0000000000000002L});
5133 public static final BitSet FOLLOW_INNER_in_join_kind514 = new BitSet(new long[]{0x0000000000080000L});
5134 public static final BitSet FOLLOW_JOIN_in_join_kind516 = new BitSet(new long[]{0x0000000000000002L});
5135 public static final BitSet FOLLOW_LEFT_in_join_kind536 = new BitSet(new long[]{0x0000000000280000L});
5136 public static final BitSet FOLLOW_OUTER_in_join_kind538 = new BitSet(new long[]{0x0000000000080000L});
5137 public static final BitSet FOLLOW_JOIN_in_join_kind541 = new BitSet(new long[]{0x0000000000000002L});
5138 public static final BitSet FOLLOW_RIGHT_in_join_kind561 = new BitSet(new long[]{0x0000000000280000L});
5139 public static final BitSet FOLLOW_OUTER_in_join_kind563 = new BitSet(new long[]{0x0000000000080000L});
5140 public static final BitSet FOLLOW_JOIN_in_join_kind566 = new BitSet(new long[]{0x0000000000000002L});
5141 public static final BitSet FOLLOW_ON_in_join_specification594 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000010L});
5142 public static final BitSet FOLLOW_column_reference_in_join_specification597 = new BitSet(new long[]{0x0001000000000000L});
5143 public static final BitSet FOLLOW_EQ_in_join_specification599 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000010L});
5144 public static final BitSet FOLLOW_column_reference_in_join_specification601 = new BitSet(new long[]{0x0000000000000002L});
5145 public static final BitSet FOLLOW_WHERE_in_where_clause616 = new BitSet(new long[]{0x084013E400000000L,0x000000000000001AL});
5146 public static final BitSet FOLLOW_search_condition_in_where_clause619 = new BitSet(new long[]{0x0000000000000002L});
5147 public static final BitSet FOLLOW_boolean_term_in_search_condition630 = new BitSet(new long[]{0x0000000200000002L});
5148 public static final BitSet FOLLOW_OR_in_search_condition633 = new BitSet(new long[]{0x084013E400000000L,0x000000000000001AL});
5149 public static final BitSet FOLLOW_boolean_term_in_search_condition636 = new BitSet(new long[]{0x0000000200000002L});
5150 public static final BitSet FOLLOW_boolean_factor_in_boolean_term649 = new BitSet(new long[]{0x0000000100000002L});
5151 public static final BitSet FOLLOW_AND_in_boolean_term652 = new BitSet(new long[]{0x084013E400000000L,0x000000000000001AL});
5152 public static final BitSet FOLLOW_boolean_factor_in_boolean_term655 = new BitSet(new long[]{0x0000000100000002L});
5153 public static final BitSet FOLLOW_NOT_in_boolean_factor668 = new BitSet(new long[]{0x084013E400000000L,0x000000000000001AL});
5154 public static final BitSet FOLLOW_boolean_test_in_boolean_factor671 = new BitSet(new long[]{0x0000000000000002L});
5155 public static final BitSet FOLLOW_boolean_test_in_boolean_factor679 = new BitSet(new long[]{0x0000000000000002L});
5156 public static final BitSet FOLLOW_predicate_in_boolean_test695 = new BitSet(new long[]{0x0000000000000002L});
5157 public static final BitSet FOLLOW_LPAR_in_boolean_test703 = new BitSet(new long[]{0x084013E400000000L,0x000000000000001AL});
5158 public static final BitSet FOLLOW_search_condition_in_boolean_test705 = new BitSet(new long[]{0x0000200000000000L});
5159 public static final BitSet FOLLOW_RPAR_in_boolean_test707 = new BitSet(new long[]{0x0000000000000002L});
5160 public static final BitSet FOLLOW_comparison_predicate_in_predicate729 = new BitSet(new long[]{0x0000000000000002L});
5161 public static final BitSet FOLLOW_in_predicate_in_predicate737 = new BitSet(new long[]{0x0000000000000002L});
5162 public static final BitSet FOLLOW_like_predicate_in_predicate745 = new BitSet(new long[]{0x0000000000000002L});
5163 public static final BitSet FOLLOW_null_predicate_in_predicate753 = new BitSet(new long[]{0x0000000000000002L});
5164 public static final BitSet FOLLOW_quantified_comparison_predicate_in_predicate761 = new BitSet(new long[]{0x0000000000000002L});
5165 public static final BitSet FOLLOW_quantified_in_predicate_in_predicate769 = new BitSet(new long[]{0x0000000000000002L});
5166 public static final BitSet FOLLOW_text_search_predicate_in_predicate777 = new BitSet(new long[]{0x0000000000000002L});
5167 public static final BitSet FOLLOW_folder_predicate_in_predicate785 = new BitSet(new long[]{0x0000000000000002L});
5168 public static final BitSet FOLLOW_value_expression_in_comparison_predicate801 = new BitSet(new long[]{0x0001000000000000L});
5169 public static final BitSet FOLLOW_EQ_in_comparison_predicate803 = new BitSet(new long[]{0x0840000000000000L,0x000000000000000AL});
5170 public static final BitSet FOLLOW_literal_in_comparison_predicate805 = new BitSet(new long[]{0x0000000000000002L});
5171 public static final BitSet FOLLOW_value_expression_in_comparison_predicate829 = new BitSet(new long[]{0x0002000000000000L});
5172 public static final BitSet FOLLOW_NEQ_in_comparison_predicate831 = new BitSet(new long[]{0x0840000000000000L,0x000000000000000AL});
5173 public static final BitSet FOLLOW_literal_in_comparison_predicate833 = new BitSet(new long[]{0x0000000000000002L});
5174 public static final BitSet FOLLOW_value_expression_in_comparison_predicate857 = new BitSet(new long[]{0x0004000000000000L});
5175 public static final BitSet FOLLOW_LT_in_comparison_predicate859 = new BitSet(new long[]{0x0840000000000000L,0x000000000000000AL});
5176 public static final BitSet FOLLOW_literal_in_comparison_predicate861 = new BitSet(new long[]{0x0000000000000002L});
5177 public static final BitSet FOLLOW_value_expression_in_comparison_predicate885 = new BitSet(new long[]{0x0008000000000000L});
5178 public static final BitSet FOLLOW_GT_in_comparison_predicate887 = new BitSet(new long[]{0x0840000000000000L,0x000000000000000AL});
5179 public static final BitSet FOLLOW_literal_in_comparison_predicate889 = new BitSet(new long[]{0x0000000000000002L});
5180 public static final BitSet FOLLOW_value_expression_in_comparison_predicate913 = new BitSet(new long[]{0x0010000000000000L});
5181 public static final BitSet FOLLOW_LTEQ_in_comparison_predicate915 = new BitSet(new long[]{0x0840000000000000L,0x000000000000000AL});
5182 public static final BitSet FOLLOW_literal_in_comparison_predicate917 = new BitSet(new long[]{0x0000000000000002L});
5183 public static final BitSet FOLLOW_value_expression_in_comparison_predicate941 = new BitSet(new long[]{0x0020000000000000L});
5184 public static final BitSet FOLLOW_GTEQ_in_comparison_predicate943 = new BitSet(new long[]{0x0840000000000000L,0x000000000000000AL});
5185 public static final BitSet FOLLOW_literal_in_comparison_predicate945 = new BitSet(new long[]{0x0000000000000002L});
5186 public static final BitSet FOLLOW_set_in_literal0 = new BitSet(new long[]{0x0000000000000002L});
5187 public static final BitSet FOLLOW_column_reference_in_in_predicate1021 = new BitSet(new long[]{0x0000000800000000L});
5188 public static final BitSet FOLLOW_IN_in_in_predicate1023 = new BitSet(new long[]{0x0000100000000000L});
5189 public static final BitSet FOLLOW_LPAR_in_in_predicate1025 = new BitSet(new long[]{0x0840000000000000L,0x000000000000000AL});
5190 public static final BitSet FOLLOW_in_value_list_in_in_predicate1027 = new BitSet(new long[]{0x0000200000000000L});
5191 public static final BitSet FOLLOW_RPAR_in_in_predicate1029 = new BitSet(new long[]{0x0000000000000002L});
5192 public static final BitSet FOLLOW_column_reference_in_in_predicate1055 = new BitSet(new long[]{0x0000000400000000L});
5193 public static final BitSet FOLLOW_NOT_in_in_predicate1057 = new BitSet(new long[]{0x0000000800000000L});
5194 public static final BitSet FOLLOW_IN_in_in_predicate1059 = new BitSet(new long[]{0x0000100000000000L});
5195 public static final BitSet FOLLOW_LPAR_in_in_predicate1061 = new BitSet(new long[]{0x0840000000000000L,0x000000000000000AL});
5196 public static final BitSet FOLLOW_in_value_list_in_in_predicate1063 = new BitSet(new long[]{0x0000200000000000L});
5197 public static final BitSet FOLLOW_RPAR_in_in_predicate1065 = new BitSet(new long[]{0x0000000000000002L});
5198 public static final BitSet FOLLOW_literal_in_in_value_list1099 = new BitSet(new long[]{0x0000400000000002L});
5199 public static final BitSet FOLLOW_COMMA_in_in_value_list1103 = new BitSet(new long[]{0x0840000000000000L,0x000000000000000AL});
5200 public static final BitSet FOLLOW_literal_in_in_value_list1105 = new BitSet(new long[]{0x0000400000000002L});
5201 public static final BitSet FOLLOW_column_reference_in_like_predicate1141 = new BitSet(new long[]{0x0000001000000000L});
5202 public static final BitSet FOLLOW_LIKE_in_like_predicate1143 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000002L});
5203 public static final BitSet FOLLOW_STRING_LIT_in_like_predicate1145 = new BitSet(new long[]{0x0000000000000002L});
5204 public static final BitSet FOLLOW_column_reference_in_like_predicate1171 = new BitSet(new long[]{0x0000000400000000L});
5205 public static final BitSet FOLLOW_NOT_in_like_predicate1173 = new BitSet(new long[]{0x0000001000000000L});
5206 public static final BitSet FOLLOW_LIKE_in_like_predicate1175 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000002L});
5207 public static final BitSet FOLLOW_STRING_LIT_in_like_predicate1177 = new BitSet(new long[]{0x0000000000000002L});
5208 public static final BitSet FOLLOW_column_reference_in_null_predicate1221 = new BitSet(new long[]{0x0000000040000000L});
5209 public static final BitSet FOLLOW_IS_in_null_predicate1223 = new BitSet(new long[]{0x0000000480000000L});
5210 public static final BitSet FOLLOW_NOT_in_null_predicate1233 = new BitSet(new long[]{0x0000000080000000L});
5211 public static final BitSet FOLLOW_NULL_in_null_predicate1235 = new BitSet(new long[]{0x0000000000000002L});
5212 public static final BitSet FOLLOW_NULL_in_null_predicate1253 = new BitSet(new long[]{0x0000000000000002L});
5213 public static final BitSet FOLLOW_literal_in_quantified_comparison_predicate1293 = new BitSet(new long[]{0x0001000000000000L});
5214 public static final BitSet FOLLOW_EQ_in_quantified_comparison_predicate1295 = new BitSet(new long[]{0x0000002000000000L});
5215 public static final BitSet FOLLOW_ANY_in_quantified_comparison_predicate1297 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000010L});
5216 public static final BitSet FOLLOW_multi_valued_column_reference_in_quantified_comparison_predicate1299 = new BitSet(new long[]{0x0000000000000002L});
5217 public static final BitSet FOLLOW_ANY_in_quantified_in_predicate1331 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000010L});
5218 public static final BitSet FOLLOW_multi_valued_column_reference_in_quantified_in_predicate1333 = new BitSet(new long[]{0x0000000C00000000L});
5219 public static final BitSet FOLLOW_NOT_in_quantified_in_predicate1343 = new BitSet(new long[]{0x0000000800000000L});
5220 public static final BitSet FOLLOW_IN_in_quantified_in_predicate1345 = new BitSet(new long[]{0x0000100000000000L});
5221 public static final BitSet FOLLOW_LPAR_in_quantified_in_predicate1347 = new BitSet(new long[]{0x0840000000000000L,0x000000000000000AL});
5222 public static final BitSet FOLLOW_in_value_list_in_quantified_in_predicate1349 = new BitSet(new long[]{0x0000200000000000L});
5223 public static final BitSet FOLLOW_RPAR_in_quantified_in_predicate1351 = new BitSet(new long[]{0x0000000000000002L});
5224 public static final BitSet FOLLOW_IN_in_quantified_in_predicate1382 = new BitSet(new long[]{0x0000100000000000L});
5225 public static final BitSet FOLLOW_LPAR_in_quantified_in_predicate1388 = new BitSet(new long[]{0x0840000000000000L,0x000000000000000AL});
5226 public static final BitSet FOLLOW_in_value_list_in_quantified_in_predicate1390 = new BitSet(new long[]{0x0000200000000000L});
5227 public static final BitSet FOLLOW_RPAR_in_quantified_in_predicate1392 = new BitSet(new long[]{0x0000000000000002L});
5228 public static final BitSet FOLLOW_CONTAINS_in_text_search_predicate1441 = new BitSet(new long[]{0x0000100000000000L});
5229 public static final BitSet FOLLOW_LPAR_in_text_search_predicate1443 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000012L});
5230 public static final BitSet FOLLOW_qualifier_in_text_search_predicate1446 = new BitSet(new long[]{0x0000400000000000L});
5231 public static final BitSet FOLLOW_COMMA_in_text_search_predicate1448 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000012L});
5232 public static final BitSet FOLLOW_text_search_expression_in_text_search_predicate1452 = new BitSet(new long[]{0x0000200000000000L});
5233 public static final BitSet FOLLOW_RPAR_in_text_search_predicate1454 = new BitSet(new long[]{0x0000000000000002L});
5234 public static final BitSet FOLLOW_IN_FOLDER_in_folder_predicate1497 = new BitSet(new long[]{0x0000100000000000L});
5235 public static final BitSet FOLLOW_IN_TREE_in_folder_predicate1503 = new BitSet(new long[]{0x0000100000000000L});
5236 public static final BitSet FOLLOW_LPAR_in_folder_predicate1507 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000012L});
5237 public static final BitSet FOLLOW_qualifier_in_folder_predicate1510 = new BitSet(new long[]{0x0000400000000000L});
5238 public static final BitSet FOLLOW_COMMA_in_folder_predicate1512 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000012L});
5239 public static final BitSet FOLLOW_folder_id_in_folder_predicate1516 = new BitSet(new long[]{0x0000200000000000L});
5240 public static final BitSet FOLLOW_RPAR_in_folder_predicate1518 = new BitSet(new long[]{0x0000000000000002L});
5241 public static final BitSet FOLLOW_ORDER_in_order_by_clause1552 = new BitSet(new long[]{0x0000000008000000L});
5242 public static final BitSet FOLLOW_BY_in_order_by_clause1554 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000010L});
5243 public static final BitSet FOLLOW_sort_specification_in_order_by_clause1556 = new BitSet(new long[]{0x0000400000000002L});
5244 public static final BitSet FOLLOW_COMMA_in_order_by_clause1560 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000010L});
5245 public static final BitSet FOLLOW_sort_specification_in_order_by_clause1562 = new BitSet(new long[]{0x0000400000000002L});
5246 public static final BitSet FOLLOW_column_reference_in_sort_specification1598 = new BitSet(new long[]{0x0000000000000002L});
5247 public static final BitSet FOLLOW_column_reference_in_sort_specification1612 = new BitSet(new long[]{0x0000000030000000L});
5248 public static final BitSet FOLLOW_set_in_sort_specification1614 = new BitSet(new long[]{0x0000000000000002L});
5249 public static final BitSet FOLLOW_ID_in_correlation_name1638 = new BitSet(new long[]{0x0000000000000002L});
5250 public static final BitSet FOLLOW_ID_in_table_name1649 = new BitSet(new long[]{0x0000000000000002L});
5251 public static final BitSet FOLLOW_ID_in_column_name1660 = new BitSet(new long[]{0x0000000000000002L});
5252 public static final BitSet FOLLOW_ID_in_multi_valued_column_name1671 = new BitSet(new long[]{0x0000000000000002L});
5253 public static final BitSet FOLLOW_STRING_LIT_in_folder_id1682 = new BitSet(new long[]{0x0000000000000002L});
5254 public static final BitSet FOLLOW_STRING_LIT_in_text_search_expression1693 = new BitSet(new long[]{0x0000000000000002L});
5255
5256 }