|
1
3 package com.jofti.parser.ejb;
4
5 import antlr.TokenBuffer;
6 import antlr.TokenStreamException;
7 import antlr.TokenStreamIOException;
8 import antlr.ANTLRException;
9 import antlr.LLkParser;
10 import antlr.Token;
11 import antlr.TokenStream;
12 import antlr.RecognitionException;
13 import antlr.NoViableAltException;
14 import antlr.MismatchedTokenException;
15 import antlr.SemanticException;
16 import antlr.ParserSharedInputState;
17 import antlr.collections.impl.BitSet;
18 import antlr.collections.AST;
19 import java.util.Hashtable  ;
20 import antlr.ASTFactory;
21 import antlr.ASTPair;
22 import antlr.collections.impl.ASTArray;
23
24 public class EJB3QueryParser extends antlr.LLkParser implements EJB3QueryParserTokenTypes
25 {
26
27 protected EJB3QueryParser(TokenBuffer tokenBuf, int k) {
28 super(tokenBuf,k);
29 tokenNames = _tokenNames;
30 buildTokenTypeASTClassMap();
31 astFactory = new ASTFactory(getTokenTypeToASTClassMap());
32 }
33
34 public EJB3QueryParser(TokenBuffer tokenBuf) {
35 this(tokenBuf,4);
36 }
37
38 protected EJB3QueryParser(TokenStream lexer, int k) {
39 super(lexer,k);
40 tokenNames = _tokenNames;
41 buildTokenTypeASTClassMap();
42 astFactory = new ASTFactory(getTokenTypeToASTClassMap());
43 }
44
45 public EJB3QueryParser(TokenStream lexer) {
46 this(lexer,4);
47 }
48
49 public EJB3QueryParser(ParserSharedInputState state) {
50 super(state,4);
51 tokenNames = _tokenNames;
52 buildTokenTypeASTClassMap();
53 astFactory = new ASTFactory(getTokenTypeToASTClassMap());
54 }
55
56 public final void queryStatement() throws RecognitionException, TokenStreamException {
57
58 returnAST = null;
59 ASTPair currentAST = new ASTPair();
60 AST queryStatement_AST = null;
61
62 try { querySpecification();
64 astFactory.addASTChild(currentAST, returnAST);
65 match(SEMICOLON);
66 queryStatement_AST = (AST)currentAST.root;
67 }
68 catch (RecognitionException ex) {
69 if (inputState.guessing==0) {
70 reportError(ex);
71 recover(ex,_tokenSet_0);
72 } else {
73 throw ex;
74 }
75 }
76 returnAST = queryStatement_AST;
77 }
78
79 public final void querySpecification() throws RecognitionException, TokenStreamException {
80
81 returnAST = null;
82 ASTPair currentAST = new ASTPair();
83 AST querySpecification_AST = null;
84
85 try { AST tmp2_AST = null;
87 tmp2_AST = astFactory.create(LT(1));
88 astFactory.makeASTRoot(currentAST, tmp2_AST);
89 match(SELECT);
90 selectList();
91 astFactory.addASTChild(currentAST, returnAST);
92 AST tmp3_AST = null;
93 tmp3_AST = astFactory.create(LT(1));
94 astFactory.makeASTRoot(currentAST, tmp3_AST);
95 match(FROM);
96 fromList();
97 astFactory.addASTChild(currentAST, returnAST);
98 {
99 switch ( LA(1)) {
100 case WHERE:
101 {
102 AST tmp4_AST = null;
103 tmp4_AST = astFactory.create(LT(1));
104 astFactory.makeASTRoot(currentAST, tmp4_AST);
105 match(WHERE);
106 predicateList();
107 astFactory.addASTChild(currentAST, returnAST);
108 break;
109 }
110 case NAMESPACE:
111 case ORDER:
112 case SEMICOLON:
113 {
114 break;
115 }
116 default:
117 {
118 throw new NoViableAltException(LT(1), getFilename());
119 }
120 }
121 }
122 {
123 switch ( LA(1)) {
124 case ORDER:
125 {
126 AST tmp5_AST = null;
127 tmp5_AST = astFactory.create(LT(1));
128 astFactory.makeASTRoot(currentAST, tmp5_AST);
129 match(ORDER);
130 match(BY);
131 orderList();
132 astFactory.addASTChild(currentAST, returnAST);
133 break;
134 }
135 case NAMESPACE:
136 case SEMICOLON:
137 {
138 break;
139 }
140 default:
141 {
142 throw new NoViableAltException(LT(1), getFilename());
143 }
144 }
145 }
146 {
147 switch ( LA(1)) {
148 case NAMESPACE:
149 {
150 AST tmp7_AST = null;
151 tmp7_AST = astFactory.create(LT(1));
152 astFactory.makeASTRoot(currentAST, tmp7_AST);
153 match(NAMESPACE);
154 nameSpace();
155 astFactory.addASTChild(currentAST, returnAST);
156 break;
157 }
158 case SEMICOLON:
159 {
160 break;
161 }
162 default:
163 {
164 throw new NoViableAltException(LT(1), getFilename());
165 }
166 }
167 }
168 querySpecification_AST = (AST)currentAST.root;
169 }
170 catch (RecognitionException ex) {
171 if (inputState.guessing==0) {
172 reportError(ex);
173 recover(ex,_tokenSet_1);
174 } else {
175 throw ex;
176 }
177 }
178 returnAST = querySpecification_AST;
179 }
180
181 public final void selectList() throws RecognitionException, TokenStreamException {
182
183 returnAST = null;
184 ASTPair currentAST = new ASTPair();
185 AST selectList_AST = null;
186
187 try { boolean synPredMatched8 = false;
189 if (((LA(1)==Identifier) && (LA(2)==COMMA||LA(2)==Identifier))) {
190 int _m8 = mark();
191 synPredMatched8 = true;
192 inputState.guessing++;
193 try {
194 {
195 className();
196 }
197 }
198 catch (RecognitionException pe) {
199 synPredMatched8 = false;
200 }
201 rewind(_m8);
202 inputState.guessing--;
203 }
204 if ( synPredMatched8 ) {
205 className();
206 astFactory.addASTChild(currentAST, returnAST);
207 {
208 int _cnt11=0;
209 _loop11:
210 do {
211 if ((LA(1)==COMMA||LA(1)==Identifier)) {
212 {
213 switch ( LA(1)) {
214 case COMMA:
215 {
216 match(COMMA);
217 break;
218 }
219 case Identifier:
220 {
221 break;
222 }
223 default:
224 {
225 throw new NoViableAltException(LT(1), getFilename());
226 }
227 }
228 }
229 className();
230 astFactory.addASTChild(currentAST, returnAST);
231 }
232 else {
233 if ( _cnt11>=1 ) { break _loop11; } else {throw new NoViableAltException(LT(1), getFilename());}
234 }
235
236 _cnt11++;
237 } while (true);
238 }
239 selectList_AST = (AST)currentAST.root;
240 }
241 else if ((LA(1)==Identifier) && (LA(2)==FROM)) {
242 className();
243 astFactory.addASTChild(currentAST, returnAST);
244 selectList_AST = (AST)currentAST.root;
245 }
246 else {
247 throw new NoViableAltException(LT(1), getFilename());
248 }
249
250 }
251 catch (RecognitionException ex) {
252 if (inputState.guessing==0) {
253 reportError(ex);
254 recover(ex,_tokenSet_2);
255 } else {
256 throw ex;
257 }
258 }
259 returnAST = selectList_AST;
260 }
261
262 public final void fromList() throws RecognitionException, TokenStreamException {
263
264 returnAST = null;
265 ASTPair currentAST = new ASTPair();
266 AST fromList_AST = null;
267
268 try { boolean synPredMatched14 = false;
270 if (((LA(1)==Identifier) && (LA(2)==ALIAS_IDENTIFIER||LA(2)==Identifier) && (_tokenSet_3.member(LA(3))) && (_tokenSet_4.member(LA(4))))) {
271 int _m14 = mark();
272 synPredMatched14 = true;
273 inputState.guessing++;
274 try {
275 {
276 fullClassName();
277 }
278 }
279 catch (RecognitionException pe) {
280 synPredMatched14 = false;
281 }
282 rewind(_m14);
283 inputState.guessing--;
284 }
285 if ( synPredMatched14 ) {
286 fullClassName();
287 astFactory.addASTChild(currentAST, returnAST);
288 {
289 _loop17:
290 do {
291 if ((LA(1)==COMMA)) {
292 match(COMMA);
293 {
294 switch ( LA(1)) {
295 case IN:
296 {
297 collectionIdentifierName();
298 astFactory.addASTChild(currentAST, returnAST);
299 break;
300 }
301 case Identifier:
302 {
303 fullClassName();
304 astFactory.addASTChild(currentAST, returnAST);
305 break;
306 }
307 default:
308 {
309 throw new NoViableAltException(LT(1), getFilename());
310 }
311 }
312 }
313 }
314 else {
315 break _loop17;
316 }
317
318 } while (true);
319 }
320 fromList_AST = (AST)currentAST.root;
321 }
322 else if ((LA(1)==Identifier) && (LA(2)==ALIAS_IDENTIFIER||LA(2)==Identifier) && (_tokenSet_5.member(LA(3))) && (_tokenSet_6.member(LA(4)))) {
323 fullClassName();
324 astFactory.addASTChild(currentAST, returnAST);
325 fromList_AST = (AST)currentAST.root;
326 }
327 else {
328 throw new NoViableAltException(LT(1), getFilename());
329 }
330
331 }
332 catch (RecognitionException ex) {
333 if (inputState.guessing==0) {
334
335 throw new RecognitionException("Expecting Classname Identifier[[,]ClassName Identifier]* :Found: " + ex);
336
337 } else {
338 throw ex;
339 }
340 }
341 returnAST = fromList_AST;
342 }
343
344 public final void predicateList() throws RecognitionException, TokenStreamException {
345
346 returnAST = null;
347 ASTPair currentAST = new ASTPair();
348 AST predicateList_AST = null;
349
350 try { subPredicate();
352 astFactory.addASTChild(currentAST, returnAST);
353 {
354 _loop36:
355 do {
356 if ((LA(1)==AND||LA(1)==OR)) {
357 {
358 switch ( LA(1)) {
359 case AND:
360 {
361 AST tmp10_AST = null;
362 tmp10_AST = astFactory.create(LT(1));
363 astFactory.addASTChild(currentAST, tmp10_AST);
364 match(AND);
365 break;
366 }
367 case OR:
368 {
369 AST tmp11_AST = null;
370 tmp11_AST = astFactory.create(LT(1));
371 astFactory.addASTChild(currentAST, tmp11_AST);
372 match(OR);
373 break;
374 }
375 default:
376 {
377 throw new NoViableAltException(LT(1), getFilename());
378 }
379 }
380 }
381 subPredicate();
382 astFactory.addASTChild(currentAST, returnAST);
383 }
384 else {
385 break _loop36;
386 }
387
388 } while (true);
389 }
390 predicateList_AST = (AST)currentAST.root;
391 }
392 catch (RecognitionException ex) {
393 if (inputState.guessing==0) {
394 reportError(ex);
395 recover(ex,_tokenSet_7);
396 } else {
397 throw ex;
398 }
399 }
400 returnAST = predicateList_AST;
401 }
402
403 public final void orderList() throws RecognitionException, TokenStreamException {
404
405 returnAST = null;
406 ASTPair currentAST = new ASTPair();
407 AST orderList_AST = null;
408
409 try { boolean synPredMatched20 = false;
411 if (((LA(1)==Identifier) && (LA(2)==ASC||LA(2)==DESC||LA(2)==COMMA) && (LA(3)==COMMA||LA(3)==Identifier) && (_tokenSet_8.member(LA(4))))) {
412 int _m20 = mark();
413 synPredMatched20 = true;
414 inputState.guessing++;
415 try {
416 {
417 orderName();
418 }
419 }
420 catch (RecognitionException pe) {
421 synPredMatched20 = false;
422 }
423 rewind(_m20);
424 inputState.guessing--;
425 }
426 if ( synPredMatched20 ) {
427 orderName();
428 astFactory.addASTChild(currentAST, returnAST);
429 {
430 switch ( LA(1)) {
431 case ASC:
432 {
433 AST tmp12_AST = null;
434 tmp12_AST = astFactory.create(LT(1));
435 astFactory.addASTChild(currentAST, tmp12_AST);
436 match(ASC);
437 break;
438 }
439 case DESC:
440 {
441 AST tmp13_AST = null;
442 tmp13_AST = astFactory.create(LT(1));
443 astFactory.addASTChild(currentAST, tmp13_AST);
444 match(DESC);
445 break;
446 }
447 case COMMA:
448 {
449 break;
450 }
451 default:
452 {
453 throw new NoViableAltException(LT(1), getFilename());
454 }
455 }
456 }
457 {
458 int _cnt24=0;
459 _loop24:
460 do {
461 if ((LA(1)==COMMA)) {
462 match(COMMA);
463 orderName();
464 astFactory.addASTChild(currentAST, returnAST);
465 {
466 switch ( LA(1)) {
467 case ASC:
468 {
469 AST tmp15_AST = null;
470 tmp15_AST = astFactory.create(LT(1));
471 astFactory.addASTChild(currentAST, tmp15_AST);
472 match(ASC);
473 break;
474 }
475 case DESC:
476 {
477 AST tmp16_AST = null;
478 tmp16_AST = astFactory.create(LT(1));
479 astFactory.addASTChild(currentAST, tmp16_AST);
480 match(DESC);
481 break;
482 }
483 case NAMESPACE:
484 case COMMA:
485 case SEMICOLON:
486 {
487 break;
488 }
489 default:
490 {
491 throw new NoViableAltException(LT(1), getFilename());
492 }
493 }
494 }
495 }
496 else {
497 if ( _cnt24>=1 ) { break _loop24; } else {throw new NoViableAltException(LT(1), getFilename());}
498 }
499
500 _cnt24++;
501 } while (true);
502 }
503 orderList_AST = (AST)currentAST.root;
504 }
505 else if ((LA(1)==Identifier) && (_tokenSet_9.member(LA(2))) && (_tokenSet_10.member(LA(3))) && (_tokenSet_10.member(LA(4)))) {
506 orderName();
507 astFactory.addASTChild(currentAST, returnAST);
508 {
509 switch ( LA(1)) {
510 case ASC:
511 {
512 AST tmp17_AST = null;
513 tmp17_AST = astFactory.create(LT(1));
514 astFactory.addASTChild(currentAST, tmp17_AST);
515 match(ASC);
516 break;
517 }
518 case DESC:
519 {
520 AST tmp18_AST = null;
521 tmp18_AST = astFactory.create(LT(1));
522 astFactory.addASTChild(currentAST, tmp18_AST);
523 match(DESC);
524 break;
525 }
526 case NAMESPACE:
527 case SEMICOLON:
528 {
529 break;
530 }
531 default:
532 {
533 throw new NoViableAltException(LT(1), getFilename());
534 }
535 }
536 }
537 orderList_AST = (AST)currentAST.root;
538 }
539 else {
540 throw new NoViableAltException(LT(1), getFilename());
541 }
542
543 }
544 catch (RecognitionException ex) {
545 if (inputState.guessing==0) {
546 reportError(ex);
547 recover(ex,_tokenSet_11);
548 } else {
549 throw ex;
550 }
551 }
552 returnAST = orderList_AST;
553 }
554
555 public final void nameSpace() throws RecognitionException, TokenStreamException {
556
557 returnAST = null;
558 ASTPair currentAST = new ASTPair();
559 AST nameSpace_AST = null;
560
561 try { {
563 int _cnt56=0;
564 _loop56:
565 do {
566 switch ( LA(1)) {
567 case FORWARDSLASH:
568 {
569 {
570 AST tmp19_AST = null;
571 tmp19_AST = astFactory.create(LT(1));
572 astFactory.addASTChild(currentAST, tmp19_AST);
573 match(FORWARDSLASH);
574 }
575 break;
576 }
577 case SELECT:
578 case WHERE:
579 case ALIAS_IDENTIFIER:
580 case AND:
581 case OR:
582 case NOT:
583 case VALUE:
584 case FROM:
585 case IS:
586 case LIKE:
587 case IN:
588 case NAMESPACE:
589 case ORDER:
590 case BY:
591 case Identifier:
592 case PredicateIdentifier:
593 case ASCENDING:
594 case DESCENDING:
595 {
596 predicateValue();
597 astFactory.addASTChild(currentAST, returnAST);
598 break;
599 }
600 case DASH:
601 {
602 {
603 AST tmp20_AST = null;
604 tmp20_AST = astFactory.create(LT(1));
605 astFactory.addASTChild(currentAST, tmp20_AST);
606 match(DASH);
607 }
608 break;
609 }
610 case PLUS:
611 {
612 {
613 AST tmp21_AST = null;
614 tmp21_AST = astFactory.create(LT(1));
615 astFactory.addASTChild(currentAST, tmp21_AST);
616 match(PLUS);
617 }
618 break;
619 }
620 default:
621 {
622 if ( _cnt56>=1 ) { break _loop56; } else {throw new NoViableAltException(LT(1), getFilename());}
623 }
624 }
625 _cnt56++;
626 } while (true);
627 }
628 nameSpace_AST = (AST)currentAST.root;
629 }
630 catch (RecognitionException ex) {
631 if (inputState.guessing==0) {
632 reportError(ex);
633 recover(ex,_tokenSet_1);
634 } else {
635 throw ex;
636 }
637 }
638 returnAST = nameSpace_AST;
639 }
640
641 public final void className() throws RecognitionException, TokenStreamException {
642
643 returnAST = null;
644 ASTPair currentAST = new ASTPair();
645 AST className_AST = null;
646
647 try { AST tmp22_AST = null;
649 tmp22_AST = astFactory.create(LT(1));
650 astFactory.addASTChild(currentAST, tmp22_AST);
651 match(Identifier);
652 className_AST = (AST)currentAST.root;
653 }
654 catch (RecognitionException ex) {
655 if (inputState.guessing==0) {
656 reportError(ex);
657 recover(ex,_tokenSet_12);
658 } else {
659 throw ex;
660 }
661 }
662 returnAST = className_AST;
663 }
664
665 public final void fullClassName() throws RecognitionException, TokenStreamException {
666
667 returnAST = null;
668 ASTPair currentAST = new ASTPair();
669 AST fullClassName_AST = null;
670
671 try { className();
673 astFactory.addASTChild(currentAST, returnAST);
674 {
675 switch ( LA(1)) {
676 case ALIAS_IDENTIFIER:
677 {
678 AST tmp23_AST = null;
679 tmp23_AST = astFactory.create(LT(1));
680 astFactory.makeASTRoot(currentAST, tmp23_AST);
681 match(ALIAS_IDENTIFIER);
682 break;
683 }
684 case Identifier:
685 {
686 break;
687 }
688 default:
689 {
690 throw new NoViableAltException(LT(1), getFilename());
691 }
692 }
693 }
694 aliasName();
695 astFactory.addASTChild(currentAST, returnAST);
696 fullClassName_AST = (AST)currentAST.root;
697 }
698 catch (RecognitionException ex) {
699 if (inputState.guessing==0) {
700 reportError(ex);
701 recover(ex,_tokenSet_13);
702 } else {
703 throw ex;
704 }
705 }
706 returnAST = fullClassName_AST;
707 }
708
709 public final void collectionIdentifierName() throws RecognitionException, TokenStreamException {
710
711 returnAST = null;
712 ASTPair currentAST = new ASTPair();
713 AST collectionIdentifierName_AST = null;
714
715 try { AST tmp24_AST = null;
717 tmp24_AST = astFactory.create(LT(1));
718 astFactory.addASTChild(currentAST, tmp24_AST);
719 match(IN);
720 AST tmp25_AST = null;
721 tmp25_AST = astFactory.create(LT(1));
722 astFactory.addASTChild(currentAST, tmp25_AST);
723 match(LPAREN);
724 className();
725 astFactory.addASTChild(currentAST, returnAST);
726 AST tmp26_AST = null;
727 tmp26_AST = astFactory.create(LT(1));
728 astFactory.addASTChild(currentAST, tmp26_AST);
729 match(RPAREN);
730 {
731 switch ( LA(1)) {
732 case ALIAS_IDENTIFIER:
733 {
734 AST tmp27_AST = null;
735 tmp27_AST = astFactory.create(LT(1));
736 astFactory.makeASTRoot(currentAST, tmp27_AST);
737 match(ALIAS_IDENTIFIER);
738 break;
739 }
740 case Identifier:
741 {
742 break;
743 }
744 default:
745 {
746 throw new NoViableAltException(LT(1), getFilename());
747 }
748 }
749 }
750 aliasName();
751 astFactory.addASTChild(currentAST, returnAST);
752 collectionIdentifierName_AST = (AST)currentAST.root;
753 }
754 catch (RecognitionException ex) {
755 if (inputState.guessing==0) {
756 reportError(ex);
757 recover(ex,_tokenSet_13);
758 } else {
759 throw ex;
760 }
761 }
762 returnAST = collectionIdentifierName_AST;
763 }
764
765 public final void orderName() throws RecognitionException, TokenStreamException {
766
767 returnAST = null;
768 ASTPair currentAST = new ASTPair();
769 AST orderName_AST = null;
770
771 try { AST tmp28_AST = null;
773 tmp28_AST = astFactory.create(LT(1));
774 astFactory.addASTChild(currentAST, tmp28_AST);
775 match(Identifier);
776 orderName_AST = (AST)currentAST.root;
777 }
778 catch (RecognitionException ex) {
779 if (inputState.guessing==0) {
780 reportError(ex);
781 recover(ex,_tokenSet_14);
782 } else {
783 throw ex;
784 }
785 }
786 returnAST = orderName_AST;
787 }
788
789 public final void aliasName() throws RecognitionException, TokenStreamException {
790
791 returnAST = null;
792 ASTPair currentAST = new ASTPair();
793 AST aliasName_AST = null;
794
795 try { AST tmp29_AST = null;
797 tmp29_AST = astFactory.create(LT(1));
798 astFactory.addASTChild(currentAST, tmp29_AST);
799 match(Identifier);
800 aliasName_AST = (AST)currentAST.root;
801 }
802 catch (RecognitionException ex) {
803 if (inputState.guessing==0) {
804 reportError(ex);
805 recover(ex,_tokenSet_13);
806 } else {
807 throw ex;
808 }
809 }
810 returnAST = aliasName_AST;
811 }
812
813 public final void subPredicate() throws RecognitionException, TokenStreamException {
814
815 returnAST = null;
816 ASTPair currentAST = new ASTPair();
817 AST subPredicate_AST = null;
818
819 try { switch ( LA(1)) {
821 case LPAREN:
822 {
823 AST tmp30_AST = null;
824 tmp30_AST = astFactory.create(LT(1));
825 astFactory.addASTChild(currentAST, tmp30_AST);
826 match(LPAREN);
827 predicateList();
828 astFactory.addASTChild(currentAST, returnAST);
829 AST tmp31_AST = null;
830 tmp31_AST = astFactory.create(LT(1));
831 astFactory.addASTChild(currentAST, tmp31_AST);
832 match(RPAREN);
833 subPredicate_AST = (AST)currentAST.root;
834 break;
835 }
836 case VALUE:
837 case Identifier:
838 {
839 predicate();
840 astFactory.addASTChild(currentAST, returnAST);
841 subPredicate_AST = (AST)currentAST.root;
842 break;
843 }
844 default:
845 {
846 throw new NoViableAltException(LT(1), getFilename());
847 }
848 }
849 }
850 catch (RecognitionException ex) {
851 if (inputState.guessing==0) {
852 reportError(ex);
853 recover(ex,_tokenSet_15);
854 } else {
855 throw ex;
856 }
857 }
858 returnAST = subPredicate_AST;
859 }
860
861 public final void predicate() throws RecognitionException, TokenStreamException {
862
863 returnAST = null;
864 ASTPair currentAST = new ASTPair();
865 AST predicate_AST = null;
866
867 try { predicateName();
869 astFactory.addASTChild(currentAST, returnAST);
870 {
871 switch ( LA(1)) {
872 case ASSIGNEQUAL:
873 {
874 AST tmp32_AST = null;
875 tmp32_AST = astFactory.create(LT(1));
876 astFactory.makeASTRoot(currentAST, tmp32_AST);
877 match(ASSIGNEQUAL);
878 break;
879 }
880 case NOTEQUAL2:
881 {
882 AST tmp33_AST = null;
883 tmp33_AST = astFactory.create(LT(1));
884 astFactory.makeASTRoot(currentAST, tmp33_AST);
885 match(NOTEQUAL2);
886 break;
887 }
888 case NOTEQUAL1:
889 {
890 AST tmp34_AST = null;
891 tmp34_AST = astFactory.create(LT(1));
892 astFactory.makeASTRoot(currentAST, tmp34_AST);
893 match(NOTEQUAL1);
894 break;
895 }
896 case LESSTHANOREQUALTO1:
897 {
898 AST tmp35_AST = null;
899 tmp35_AST = astFactory.create(LT(1));
900 astFactory.makeASTRoot(currentAST, tmp35_AST);
901 match(LESSTHANOREQUALTO1);
902 break;
903 }
904 case LESSTHANOREQUALTO2:
905 {
906 AST tmp36_AST = null;
907 tmp36_AST = astFactory.create(LT(1));
908 astFactory.makeASTRoot(currentAST, tmp36_AST);
909 match(LESSTHANOREQUALTO2);
910 break;
911 }
912 case LESSTHAN:
913 {
914 AST tmp37_AST = null;
915 tmp37_AST = astFactory.create(LT(1));
916 astFactory.makeASTRoot(currentAST, tmp37_AST);
917 match(LESSTHAN);
918 break;
919 }
920 case GREATERTHANOREQUALTO1:
921 {
922 AST tmp38_AST = null;
923 tmp38_AST = astFactory.create(LT(1));
924 astFactory.makeASTRoot(currentAST, tmp38_AST);
925 match(GREATERTHANOREQUALTO1);
926 break;
927 }
928 case GREATERTHANOREQUALTO2:
929 {
930 AST tmp39_AST = null;
931 tmp39_AST = astFactory.create(LT(1));
932 astFactory.makeASTRoot(currentAST, tmp39_AST);
933 match(GREATERTHANOREQUALTO2);
934 break;
935 }
936 case GREATERTHAN:
937 {
938 AST tmp40_AST = null;
939 tmp40_AST = astFactory.create(LT(1));
940 astFactory.makeASTRoot(currentAST, tmp40_AST);
941 match(GREATERTHAN);
942 break;
943 }
944 case IS:
945 {
946 AST tmp41_AST = null;
947 tmp41_AST = astFactory.create(LT(1));
948 astFactory.makeASTRoot(currentAST, tmp41_AST);
949 match(IS);
950 break;
951 }
952 case NOT:
953 {
954 AST tmp42_AST = null;
955 tmp42_AST = astFactory.create(LT(1));
956 astFactory.makeASTRoot(currentAST, tmp42_AST);
957 match(NOT);
958 break;
959 }
960 case LIKE:
961 {
962 AST tmp43_AST = null;
963 tmp43_AST = astFactory.create(LT(1));
964 astFactory.makeASTRoot(currentAST, tmp43_AST);
965 match(LIKE);
966 break;
967 }
968 case IN:
969 {
970 AST tmp44_AST = null;
971 tmp44_AST = astFactory.create(LT(1));
972 astFactory.makeASTRoot(currentAST, tmp44_AST);
973 match(IN);
974 break;
975 }
976 default:
977 {
978 throw new NoViableAltException(LT(1), getFilename());
979 }
980 }
981 }
982 predicateParenValue();
983 astFactory.addASTChild(currentAST, returnAST);
984 predicate_AST = (AST)currentAST.root;
985 }
986 catch (RecognitionException ex) {
987 if (inputState.guessing==0) {
988 reportError(ex);
989 recover(ex,_tokenSet_15);
990 } else {
991 throw ex;
992 }
993 }
994 returnAST = predicate_AST;
995 }
996
997 public final void predicateName() throws RecognitionException, TokenStreamException {
998
999 returnAST = null;
1000 ASTPair currentAST = new ASTPair();
1001 AST predicateName_AST = null;
1002
1003 try { switch ( LA(1)) {
1005 case Identifier:
1006 {
1007 AST tmp45_AST = null;
1008 tmp45_AST = astFactory.create(LT(1));
1009 astFactory.addASTChild(currentAST, tmp45_AST);
1010 match(Identifier);
1011 predicateName_AST = (AST)currentAST.root;
1012 break;
1013 }
1014 case VALUE:
1015 {
1016 AST tmp46_AST = null;
1017 tmp46_AST = astFactory.create(LT(1));
1018 astFactory.addASTChild(currentAST, tmp46_AST);
1019 match(VALUE);
1020 predicateName_AST = (AST)currentAST.root;
1021 break;
1022 }
1023 default:
1024 {
1025 throw new NoViableAltException(LT(1), getFilename());
1026 }
1027 }
1028 }
1029 catch (RecognitionException ex) {
1030 if (inputState.guessing==0) {
1031 reportError(ex);
1032 recover(ex,_tokenSet_16);
1033 } else {
1034 throw ex;
1035 }
1036 }
1037 returnAST = predicateName_AST;
1038 }
1039
1040 public final void predicateParenValue() throws RecognitionException, TokenStreamException {
1041
1042 returnAST = null;
1043 ASTPair currentAST = new ASTPair();
1044 AST predicateParenValue_AST = null;
1045
1046 try { switch ( LA(1)) {
1048 case LPAREN:
1049 {
1050 AST tmp47_AST = null;
1051 tmp47_AST = astFactory.create(LT(1));
1052 astFactory.addASTChild(currentAST, tmp47_AST);
1053 match(LPAREN);
1054 {
1055 _loop46:
1056 do {
1057 switch ( LA(1)) {
1058 case SELECT:
1059 case WHERE:
1060 case ALIAS_IDENTIFIER:
1061 case AND:
1062 case OR:
1063 case NOT:
1064 case VALUE:
1065 case FROM:
1066 case IS:
1067 case LIKE:
1068 case IN:
1069 case NAMESPACE:
1070 case ORDER:
1071 case BY:
1072 case Identifier:
1073 case PredicateIdentifier:
1074 case ASCENDING:
1075 case DESCENDING:
1076 {
1077 predicateValue();
1078 astFactory.addASTChild(currentAST, returnAST);
1079 break;
1080 }
1081 case COMMA:
1082 {
1083 AST tmp48_AST = null;
1084 tmp48_AST = astFactory.create(LT(1));
1085 astFactory.addASTChild(currentAST, tmp48_AST);
1086 match(COMMA);
1087 break;
1088 }
1089 default:
1090 {
1091 break _loop46;
1092 }
1093 }
1094 } while (true);
1095 }
1096 AST tmp49_AST = null;
1097 tmp49_AST = astFactory.create(LT(1));
1098 astFactory.addASTChild(currentAST, tmp49_AST);
1099 match(RPAREN);
1100 predicateParenValue_AST = (AST)currentAST.root;
1101 break;
1102 }
1103 case SELECT:
1104 case WHERE:
1105 case ALIAS_IDENTIFIER:
1106 case AND:
1107 case OR:
1108 case NOT:
1109 case VALUE:
1110 case FROM:
1111 case IS:
1112 case LIKE:
1113 case IN:
1114 case NAMESPACE:
1115 case ORDER:
1116 case BY:
1117 case Identifier:
1118 case PredicateIdentifier:
1119 case ASCENDING:
1120 case DESCENDING:
1121 {
1122 predicateValue();
1123 astFactory.addASTChild(currentAST, returnAST);
1124 predicateParenValue_AST = (AST)currentAST.root;
1125 break;
1126 }
1127 default:
1128 {
1129 throw new NoViableAltException(LT(1), getFilename());
1130 }
1131 }
1132 }
1133 catch (RecognitionException ex) {
1134 if (inputState.guessing==0) {
1135 reportError(ex);
1136 recover(ex,_tokenSet_15);
1137 } else {
1138 throw ex;
1139 }
1140 }
1141 returnAST = predicateParenValue_AST;
1142 }
1143
1144 public final void predicateValue() throws RecognitionException, TokenStreamException {
1145
1146 returnAST = null;
1147 ASTPair currentAST = new ASTPair();
1148 AST predicateValue_AST = null;
1149
1150 try { switch ( LA(1)) {
1152 case PredicateIdentifier:
1153 {
1154 AST tmp50_AST = null;
1155 tmp50_AST = astFactory.create(LT(1));
1156 astFactory.addASTChild(currentAST, tmp50_AST);
1157 match(PredicateIdentifier);
1158 predicateValue_AST = (AST)currentAST.root;
1159 break;
1160 }
1161 case Identifier:
1162 {
1163 AST tmp51_AST = null;
1164 tmp51_AST = astFactory.create(LT(1));
1165 astFactory.addASTChild(currentAST, tmp51_AST);
1166 match(Identifier);
1167 predicateValue_AST = (AST)currentAST.root;
1168 break;
1169 }
1170 case SELECT:
1171 {
1172 AST tmp52_AST = null;
1173 tmp52_AST = astFactory.create(LT(1));
1174 astFactory.addASTChild(currentAST, tmp52_AST);
1175 match(SELECT);
1176 predicateValue_AST = (AST)currentAST.root;
1177 break;
1178 }
1179 case FROM:
1180 {
1181 AST tmp53_AST = null;
1182 tmp53_AST = astFactory.create(LT(1));
1183 astFactory.addASTChild(currentAST, tmp53_AST);
1184 match(FROM);
1185 predicateValue_AST = (AST)currentAST.root;
1186 break;
1187 }
1188 case WHERE:
1189 {
1190 AST tmp54_AST = null;
1191 tmp54_AST = astFactory.create(LT(1));
1192 astFactory.addASTChild(currentAST, tmp54_AST);
1193 match(WHERE);
1194 predicateValue_AST = (AST)currentAST.root;
1195 break;
1196 }
1197 case ALIAS_IDENTIFIER:
1198 {
1199 AST tmp55_AST = null;
1200 tmp55_AST = astFactory.create(LT(1));
1201 astFactory.addASTChild(currentAST, tmp55_AST);
1202 match(ALIAS_IDENTIFIER);
1203 predicateValue_AST = (AST)currentAST.root;
1204 break;
1205 }
1206 case AND:
1207 {
1208 AST tmp56_AST = null;
1209 tmp56_AST = astFactory.create(LT(1));
1210 astFactory.addASTChild(currentAST, tmp56_AST);
1211 match(AND);
1212 predicateValue_AST = (AST)currentAST.root;
1213 break;
1214 }
1215 case OR:
1216 {
1217 AST tmp57_AST = null;
1218 tmp57_AST = astFactory.create(LT(1));
1219 astFactory.addASTChild(currentAST, tmp57_AST);
1220 match(OR);
1221 predicateValue_AST = (AST)currentAST.root;
1222 break;
1223 }
1224 case NOT:
1225 {
1226 AST tmp58_AST = null;
1227 tmp58_AST = astFactory.create(LT(1));
1228 astFactory.addASTChild(currentAST, tmp58_AST);
1229 match(NOT);
1230 predicateValue_AST = (AST)currentAST.root;
1231 break;
1232 }
1233 case VALUE:
1234 {
1235 AST tmp59_AST = null;
1236 tmp59_AST = astFactory.create(LT(1));
1237 astFactory.addASTChild(currentAST, tmp59_AST);
1238 match(VALUE);
1239 predicateValue_AST = (AST)currentAST.root;
1240 break;
1241 }
1242 case IS:
1243 {
1244 AST tmp60_AST = null;
1245 tmp60_AST = astFactory.create(LT(1));
1246 astFactory.addASTChild(currentAST, tmp60_AST);
1247 match(IS);
1248 predicateValue_AST = (AST)currentAST.root;
1249 break;
1250 }
1251 case LIKE:
1252 {
1253 AST tmp61_AST = null;
1254 tmp61_AST = astFactory.create(LT(1));
1255 astFactory.addASTChild(currentAST, tmp61_AST);
1256 match(LIKE);
1257 predicateValue_AST = (AST)currentAST.root;
1258 break;
1259 }
1260 case IN:
1261 {
1262 AST tmp62_AST = null;
1263 tmp62_AST = astFactory.create(LT(1));
1264 astFactory.addASTChild(currentAST, tmp62_AST);
1265 match(IN);
1266 predicateValue_AST = (AST)currentAST.root;
1267 break;
1268 }
1269 case NAMESPACE:
1270 {
1271 AST tmp63_AST = null;
1272 tmp63_AST = astFactory.create(LT(1));
1273 astFactory.addASTChild(currentAST, tmp63_AST);
1274 match(NAMESPACE);
1275 predicateValue_AST = (AST)currentAST.root;
1276 break;
1277 }
1278 case ORDER:
1279 {
1280 AST tmp64_AST = null;
1281 tmp64_AST = astFactory.create(LT(1));
1282 astFactory.addASTChild(currentAST, tmp64_AST);
1283 match(ORDER);
1284 predicateValue_AST = (AST)currentAST.root;
1285 break;
1286 }
1287 case BY:
1288 {
1289 AST tmp65_AST = null;
1290 tmp65_AST = astFactory.create(LT(1));
1291 astFactory.addASTChild(currentAST, tmp65_AST);
1292 match(BY);
1293 predicateValue_AST = (AST)currentAST.root;
1294 break;
1295 }
1296 case ASCENDING:
1297 {
1298 AST tmp66_AST = null;
1299 tmp66_AST = astFactory.create(LT(1));
1300 astFactory.addASTChild(currentAST, tmp66_AST);
1301 match(ASCENDING);
1302 predicateValue_AST = (AST)currentAST.root;
1303 break;
1304 }
1305 case DESCENDING:
1306 {
1307 AST tmp67_AST = null;
1308 tmp67_AST = astFactory.create(LT(1));
1309 astFactory.addASTChild(currentAST, tmp67_AST);
1310 match(DESCENDING);
1311 predicateValue_AST = (AST)currentAST.root;
1312 break;
1313 }
1314 default:
1315 {
1316 throw new NoViableAltException(LT(1), getFilename());
1317 }
1318 }
1319 }
1320 catch (RecognitionException ex) {
1321 if (inputState.guessing==0) {
1322 reportError(ex);
1323 recover(ex,_tokenSet_17);
1324 } else {
1325 throw ex;
1326 }
1327 }
1328 returnAST = predicateValue_AST;
1329 }
1330
1331 public final void comparisonOperator() throws RecognitionException, TokenStreamException {
1332
1333 returnAST = null;
1334 ASTPair currentAST = new ASTPair();
1335 AST comparisonOperator_AST = null;
1336
1337 try { switch ( LA(1)) {
1339 case ASSIGNEQUAL:
1340 {
1341 AST tmp68_AST = null;
1342 tmp68_AST = astFactory.create(LT(1));
1343 astFactory.addASTChild(currentAST, tmp68_AST);
1344 match(ASSIGNEQUAL);
1345 comparisonOperator_AST = (AST)currentAST.root;
1346 break;
1347 }
1348 case NOTEQUAL1:
1349 {
1350 AST tmp69_AST = null;
1351 tmp69_AST = astFactory.create(LT(1));
1352 astFactory.addASTChild(currentAST, tmp69_AST);
1353 match(NOTEQUAL1);
1354 comparisonOperator_AST = (AST)currentAST.root;
1355 break;
1356 }
1357 case NOTEQUAL2:
1358 {
1359 AST tmp70_AST = null;
1360 tmp70_AST = astFactory.create(LT(1));
1361 astFactory.addASTChild(currentAST, tmp70_AST);
1362 match(NOTEQUAL2);
1363 comparisonOperator_AST = (AST)currentAST.root;
1364 break;
1365 }
1366 case LESSTHANOREQUALTO1:
1367 {
1368 AST tmp71_AST = null;
1369 tmp71_AST = astFactory.create(LT(1));
1370 astFactory.addASTChild(currentAST, tmp71_AST);
1371 match(LESSTHANOREQUALTO1);
1372 comparisonOperator_AST = (AST)currentAST.root;
1373 break;
1374 }
1375 case LESSTHANOREQUALTO2:
1376 {
1377 AST tmp72_AST = null;
1378 tmp72_AST = astFactory.create(LT(1));
1379 astFactory.addASTChild(currentAST, tmp72_AST);
1380 match(LESSTHANOREQUALTO2);
1381 comparisonOperator_AST = (AST)currentAST.root;
1382 break;
1383 }
1384 case LESSTHAN:
1385 {
1386 AST tmp73_AST = null;
1387 tmp73_AST = astFactory.create(LT(1));
1388 astFactory.addASTChild(currentAST, tmp73_AST);
1389 match(LESSTHAN);
1390 comparisonOperator_AST = (AST)currentAST.root;
1391 break;
1392 }
1393 case GREATERTHANOREQUALTO1:
1394 {
1395 AST tmp74_AST = null;
1396 tmp74_AST = astFactory.create(LT(1));
1397 astFactory.addASTChild(currentAST, tmp74_AST);
1398 match(GREATERTHANOREQUALTO1);
1399 comparisonOperator_AST = (AST)currentAST.root;
1400 break;
1401 }
1402 case GREATERTHANOREQUALTO2:
1403 {
1404 AST tmp75_AST = null;
1405 tmp75_AST = astFactory.create(LT(1));
1406 astFactory.addASTChild(currentAST, tmp75_AST);
1407 match(GREATERTHANOREQUALTO2);
1408 comparisonOperator_AST = (AST)currentAST.root;
1409 break;
1410 }
1411 case GREATERTHAN:
1412 {
1413 AST tmp76_AST = null;
1414 tmp76_AST = astFactory.create(LT(1));
1415 astFactory.addASTChild(currentAST, tmp76_AST);
1416 match(GREATERTHAN);
1417 comparisonOperator_AST = (AST)currentAST.root;
1418 break;
1419 }
1420 default:
1421 {
1422 throw new NoViableAltException(LT(1), getFilename());
1423 }
1424 }
1425 }
1426 catch (RecognitionException ex) {
1427 if (inputState.guessing==0) {
1428 reportError(ex);
1429 recover(ex,_tokenSet_0);
1430 } else {
1431 throw ex;
1432 }
1433 }
1434 returnAST = comparisonOperator_AST;
1435 }
1436
1437 public final void logicalOperator() throws RecognitionException, TokenStreamException {
1438
1439 returnAST = null;
1440 ASTPair currentAST = new ASTPair();
1441 AST logicalOperator_AST = null;
1442
1443 try { switch ( LA(1)) {
1445 case AND:
1446 {
1447 AST tmp77_AST = null;
1448 tmp77_AST = astFactory.create(LT(1));
1449 astFactory.addASTChild(currentAST, tmp77_AST);
1450 match(AND);
1451 logicalOperator_AST = (AST)currentAST.root;
1452 break;
1453 }
1454 case OR:
1455 {
1456 AST tmp78_AST = null;
1457 tmp78_AST = astFactory.create(LT(1));
1458 astFactory.addASTChild(currentAST, tmp78_AST);
1459 match(OR);
1460 logicalOperator_AST = (AST)currentAST.root;
1461 break;
1462 }
1463 default:
1464 {
1465 throw new NoViableAltException(LT(1), getFilename());
1466 }
1467 }
1468 }
1469 catch (RecognitionException ex) {
1470 if (inputState.guessing==0) {
1471 reportError(ex);
1472 recover(ex,_tokenSet_0);
1473 } else {
1474 throw ex;
1475 }
1476 }
1477 returnAST = logicalOperator_AST;
1478 }
1479
1480
1481 public static final String [] _tokenNames = {
1482 "<0>",
1483 "EOF",
1484 "<2>",
1485 "NULL_TREE_LOOKAHEAD",
1486 "\"select\"",
1487 "\"where\"",
1488 "\"as\"",
1489 "\"and\"",
1490 "\"or\"",
1491 "\"not\"",
1492 "\"value\"",
1493 "\"from\"",
1494 "\"is\"",
1495 "\"like\"",
1496 "\"in\"",
1497 "\"namespace\"",
1498 "\"order\"",
1499 "\"by\"",
1500 "\"asc\"",
1501 "\"desc\"",
1502 "PACKAGE_SEPERATOR",
1503 "COMMA",
1504 "SEMICOLON",
1505 "LPAREN",
1506 "RPAREN",
1507 "SINGLE_QUOTE",
1508 "BACKSLASH",
1509 "FORWARDSLASH",
1510 "DASH",
1511 "PLUS",
1512 "ASSIGNEQUAL",
1513 "NOTEQUAL1",
1514 "NOTEQUAL2",
1515 "LESSTHANOREQUALTO1",
1516 "LESSTHANOREQUALTO2",
1517 "LESSTHAN",
1518 "GREATERTHANOREQUALTO1",
1519 "GREATERTHANOREQUALTO2",
1520 "GREATERTHAN",
1521 "LBRACKET",
1522 "RBRACKET",
1523 "Letter",
1524 "Digit",
1525 "SPACE",
1526 "Identifier",
1527 "ESC",
1528 "NONESC",
1529 "PredicateIdentifier",
1530 "WS",
1531 "ASCENDING",
1532 "DESCENDING"
1533 };
1534
1535 protected void buildTokenTypeASTClassMap() {
1536 tokenTypeToASTClassMap=null;
1537 };
1538
1539 private static final long[] mk_tokenSet_0() {
1540 long[] data = { 2L, 0L};
1541 return data;
1542 }
1543 public static final BitSet _tokenSet_0 = new BitSet(mk_tokenSet_0());
1544 private static final long[] mk_tokenSet_1() {
1545 long[] data = { 4194304L, 0L};
1546 return data;
1547 }
1548 public static final BitSet _tokenSet_1 = new BitSet(mk_tokenSet_1());
1549 private static final long[] mk_tokenSet_2() {
1550 long[] data = { 2048L, 0L};
1551 return data;
1552 }
1553 public static final BitSet _tokenSet_2 = new BitSet(mk_tokenSet_2());
1554 private static final long[] mk_tokenSet_3() {
1555 long[] data = { 17592192434208L, 0L};
1556 return data;
1557 }
1558 public static final BitSet _tokenSet_3 = new BitSet(mk_tokenSet_3());
1559 private static final long[] mk_tokenSet_4() {
1560 long[] data = { 1847180489129970L, 0L};
1561 return data;
1562 }
1563 public static final BitSet _tokenSet_4 = new BitSet(mk_tokenSet_4());
1564 private static final long[] mk_tokenSet_5() {
1565 long[] data = { 17592190337056L, 0L};
1566 return data;
1567 }
1568 public static final BitSet _tokenSet_5 = new BitSet(mk_tokenSet_5());
1569 private static final long[] mk_tokenSet_6() {
1570 long[] data = { 1847180487032818L, 0L};
1571 return data;
1572 }
1573 public static final BitSet _tokenSet_6 = new BitSet(mk_tokenSet_6());
1574 private static final long[] mk_tokenSet_7() {
1575 long[] data = { 21069824L, 0L};
1576 return data;
1577 }
1578 public static final BitSet _tokenSet_7 = new BitSet(mk_tokenSet_7());
1579 private static final long[] mk_tokenSet_8() {
1580 long[] data = { 17592193155072L, 0L};
1581 return data;
1582 }
1583 public static final BitSet _tokenSet_8 = new BitSet(mk_tokenSet_8());
1584 private static final long[] mk_tokenSet_9() {
1585 long[] data = { 5013504L, 0L};
1586 return data;
1587 }
1588 public static final BitSet _tokenSet_9 = new BitSet(mk_tokenSet_9());
1589 private static final long[] mk_tokenSet_10() {
1590 long[] data = { 1847180478644210L, 0L};
1591 return data;
1592 }
1593 public static final BitSet _tokenSet_10 = new BitSet(mk_tokenSet_10());
1594 private static final long[] mk_tokenSet_11() {
1595 long[] data = { 4227072L, 0L};
1596 return data;
1597 }
1598 public static final BitSet _tokenSet_11 = new BitSet(mk_tokenSet_11());
1599 private static final long[] mk_tokenSet_12() {
1600 long[] data = { 17592204920896L, 0L};
1601 return data;
1602 }
1603 public static final BitSet _tokenSet_12 = new BitSet(mk_tokenSet_12());
1604 private static final long[] mk_tokenSet_13() {
1605 long[] data = { 6389792L, 0L};
1606 return data;
1607 }
1608 public static final BitSet _tokenSet_13 = new BitSet(mk_tokenSet_13());
1609 private static final long[] mk_tokenSet_14() {
1610 long[] data = { 7110656L, 0L};
1611 return data;
1612 }
1613 public static final BitSet _tokenSet_14 = new BitSet(mk_tokenSet_14());
1614 private static final long[] mk_tokenSet_15() {
1615 long[] data = { 21070208L, 0L};
1616 return data;
1617 }
1618 public static final BitSet _tokenSet_15 = new BitSet(mk_tokenSet_15());
1619 private static final long[] mk_tokenSet_16() {
1620 long[] data = { 548682101248L, 0L};
1621 return data;
1622 }
1623 public static final BitSet _tokenSet_16 = new BitSet(mk_tokenSet_16());
1624 private static final long[] mk_tokenSet_17() {
1625 long[] data = { 1847180497518576L, 0L};
1626 return data;
1627 }
1628 public static final BitSet _tokenSet_17 = new BitSet(mk_tokenSet_17());
1629
1630 }
1631 |
Popular Tags |
Java API By Example, From Geeks To Geeks.