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