|
1
46
48
49
50 package org.mr.api.jms.selector.parser;
51
52 import java.util.HashSet  ;
53
54 import org.mr.api.jms.selector.syntax.Context;
55 import org.mr.api.jms.selector.syntax.Expression;
56 import org.mr.api.jms.selector.syntax.ExpressionFactory;
57 import org.mr.api.jms.selector.syntax.SelectorException;
58 import org.mr.api.jms.selector.syntax.Type;
59
60
65
66
67 import antlr.Token;
68 import antlr.collections.AST;
69 import antlr.RecognitionException;
70
71 import antlr.NoViableAltException;
72 import antlr.MismatchedTokenException;
73
74
75
76 public class SelectorTreeParser extends antlr.TreeParser implements SelectorTreeParserTokenTypes
77 {
78
79
82 private ExpressionFactory factory;
83
84 public void initialise(ExpressionFactory factory) {
85 this.factory = factory;
86 }
88 private void rethrow(String msg, AST node, Token token)
89 throws SelectorException {
90 if (node != null) {
91 throw new SelectorException(((SelectorAST) node).getContext(),
92 msg);
93 } else {
95 Context context = new Context(token.getLine(), token.getColumn());
96 throw new SelectorException(context, msg);
97 } }public SelectorTreeParser() {
100 tokenNames = _tokenNames;
101 }
102
103 public final Expression selector(AST _t) throws RecognitionException {
104 Expression expr;
105
106 SelectorAST selector_AST_in = (SelectorAST)_t;
107 SelectorAST p = null;
108
109 expr = null;
110
111
112 try { p = _t==ASTNULL ? null : (SelectorAST)_t;
114 expr=primaryExpression(_t);
115 _t = _retTree;
116
117 TypeChecker.check(p, Type.BOOLEAN);
118
119 }
120 catch (NoViableAltException error) {
121
122 rethrow(error.getMessage(), error.node, error.token);
123
124 }
125 catch (MismatchedTokenException error) {
126
127 rethrow(error.getMessage(), error.node, error.token);
128
129 }
130 _retTree = _t;
131 return expr;
132 }
133
134 public final Expression primaryExpression(AST _t) throws RecognitionException {
135 Expression expr;
136
137 SelectorAST primaryExpression_AST_in = (SelectorAST)_t;
138 SelectorAST p = null;
139 SelectorAST orl = null;
140 SelectorAST orr = null;
141 SelectorAST andl = null;
142 SelectorAST andr = null;
143 SelectorAST eql = null;
144 SelectorAST eqr = null;
145 SelectorAST nel = null;
146 SelectorAST ner = null;
147 SelectorAST ltl = null;
148 SelectorAST ltr = null;
149 SelectorAST gtl = null;
150 SelectorAST gtr = null;
151 SelectorAST lel = null;
152 SelectorAST ler = null;
153 SelectorAST gel = null;
154 SelectorAST ger = null;
155
156 expr = null;
157 AST ast = primaryExpression_AST_in;
158 SelectorAST left = null;
159 SelectorAST right = null;
160 Expression lhs = null;
161 Expression rhs = null;
162
163
164 if (_t==null) _t=ASTNULL;
165 switch ( _t.getType()) {
166 case LITERAL_not:
167 {
168 AST __t3 = _t;
169 SelectorAST tmp1_AST_in = (SelectorAST)_t;
170 match(_t,LITERAL_not);
171 _t = _t.getFirstChild();
172 p = _t==ASTNULL ? null : (SelectorAST)_t;
173 expr=primaryExpression(_t);
174 _t = _retTree;
175 _t = __t3;
176 _t = _t.getNextSibling();
177
178 TypeChecker.check(ast.getText(), p, Type.BOOLEAN);
179 expr = factory.unaryOperator(ast.getType(), expr);
180
181 break;
182 }
183 case LITERAL_or:
184 case LITERAL_and:
185 {
186 {
187 if (_t==null) _t=ASTNULL;
188 switch ( _t.getType()) {
189 case LITERAL_or:
190 {
191 AST __t5 = _t;
192 SelectorAST tmp2_AST_in = (SelectorAST)_t;
193 match(_t,LITERAL_or);
194 _t = _t.getFirstChild();
195 orl = _t==ASTNULL ? null : (SelectorAST)_t;
196 lhs=primaryExpression(_t);
197 _t = _retTree;
198 orr = _t==ASTNULL ? null : (SelectorAST)_t;
199 rhs=primaryExpression(_t);
200 _t = _retTree;
201 _t = __t5;
202 _t = _t.getNextSibling();
203
204 TypeChecker.check(ast.getText(), orl, orr, Type.BOOLEAN);
205
206 break;
207 }
208 case LITERAL_and:
209 {
210 AST __t6 = _t;
211 SelectorAST tmp3_AST_in = (SelectorAST)_t;
212 match(_t,LITERAL_and);
213 _t = _t.getFirstChild();
214 andl = _t==ASTNULL ? null : (SelectorAST)_t;
215 lhs=primaryExpression(_t);
216 _t = _retTree;
217 andr = _t==ASTNULL ? null : (SelectorAST)_t;
218 rhs=primaryExpression(_t);
219 _t = _retTree;
220 _t = __t6;
221 _t = _t.getNextSibling();
222
223 TypeChecker.check(ast.getText(), andl, andr, Type.BOOLEAN);
224
225 break;
226 }
227 default:
228 {
229 throw new NoViableAltException(_t);
230 }
231 }
232 }
233
234 expr = factory.binaryOperator(ast.getType(), lhs, rhs);
235
236 break;
237 }
238 case EQUAL:
239 case NOT_EQUAL:
240 {
241 {
242 if (_t==null) _t=ASTNULL;
243 switch ( _t.getType()) {
244 case EQUAL:
245 {
246 AST __t8 = _t;
247 SelectorAST tmp4_AST_in = (SelectorAST)_t;
248 match(_t,EQUAL);
249 _t = _t.getFirstChild();
250 eql = _t==ASTNULL ? null : (SelectorAST)_t;
251 lhs=expression(_t);
252 _t = _retTree;
253 eqr = _t==ASTNULL ? null : (SelectorAST)_t;
254 rhs=expression(_t);
255 _t = _retTree;
256 _t = __t8;
257 _t = _t.getNextSibling();
258
259 TypeChecker.checkComparison(ast.getText(), eql, eqr);
260
261 break;
262 }
263 case NOT_EQUAL:
264 {
265 AST __t9 = _t;
266 SelectorAST tmp5_AST_in = (SelectorAST)_t;
267 match(_t,NOT_EQUAL);
268 _t = _t.getFirstChild();
269 nel = _t==ASTNULL ? null : (SelectorAST)_t;
270 lhs=expression(_t);
271 _t = _retTree;
272 ner = _t==ASTNULL ? null : (SelectorAST)_t;
273 rhs=expression(_t);
274 _t = _retTree;
275 _t = __t9;
276 _t = _t.getNextSibling();
277
278 TypeChecker.checkComparison(ast.getText(), nel, ner);
279
280 break;
281 }
282 default:
283 {
284 throw new NoViableAltException(_t);
285 }
286 }
287 }
288
289 expr = factory.binaryOperator(ast.getType(), lhs, rhs);
290
291 break;
292 }
293 case LT:
294 case GT:
295 case LE:
296 case GE:
297 {
298 {
299 if (_t==null) _t=ASTNULL;
300 switch ( _t.getType()) {
301 case LT:
302 {
303 AST __t11 = _t;
304 SelectorAST tmp6_AST_in = (SelectorAST)_t;
305 match(_t,LT);
306 _t = _t.getFirstChild();
307 ltl = _t==ASTNULL ? null : (SelectorAST)_t;
308 lhs=expression(_t);
309 _t = _retTree;
310 ltr = _t==ASTNULL ? null : (SelectorAST)_t;
311 rhs=expression(_t);
312 _t = _retTree;
313 _t = __t11;
314 _t = _t.getNextSibling();
315
316 TypeChecker.check(ast.getText(), ltl, ltr, Type.NUMERIC);
317
318 break;
319 }
320 case GT:
321 {
322 AST __t12 = _t;
323 SelectorAST tmp7_AST_in = (SelectorAST)_t;
324 match(_t,GT);
325 _t = _t.getFirstChild();
326 gtl = _t==ASTNULL ? null : (SelectorAST)_t;
327 lhs=expression(_t);
328 _t = _retTree;
329 gtr = _t==ASTNULL ? null : (SelectorAST)_t;
330 rhs=expression(_t);
331 _t = _retTree;
332 _t = __t12;
333 _t = _t.getNextSibling();
334
335 TypeChecker.check(ast.getText(), gtl, gtr, Type.NUMERIC);
336
337 break;
338 }
339 case LE:
340 {
341 AST __t13 = _t;
342 SelectorAST tmp8_AST_in = (SelectorAST)_t;
343 match(_t,LE);
344 _t = _t.getFirstChild();
345 lel = _t==ASTNULL ? null : (SelectorAST)_t;
346 lhs=expression(_t);
347 _t = _retTree;
348 ler = _t==ASTNULL ? null : (SelectorAST)_t;
349 rhs=expression(_t);
350 _t = _retTree;
351 _t = __t13;
352 _t = _t.getNextSibling();
353
354 TypeChecker.check(ast.getText(), lel, ler, Type.NUMERIC);
355
356 break;
357 }
358 case GE:
359 {
360 AST __t14 = _t;
361 SelectorAST tmp9_AST_in = (SelectorAST)_t;
362 match(_t,GE);
363 _t = _t.getFirstChild();
364 gel = _t==ASTNULL ? null : (SelectorAST)_t;
365 lhs=expression(_t);
366 _t = _retTree;
367 ger = _t==ASTNULL ? null : (SelectorAST)_t;
368 rhs=expression(_t);
369 _t = _retTree;
370 _t = __t14;
371 _t = _t.getNextSibling();
372
373 TypeChecker.check(ast.getText(), gel, ger, Type.NUMERIC);
374
375 break;
376 }
377 default:
378 {
379 throw new NoViableAltException(_t);
380 }
381 }
382 }
383
384 expr = factory.binaryOperator(ast.getType(), lhs, rhs);
385
386 break;
387 }
388 case UNARY_MINUS:
389 case PLUS:
390 case MINUS:
391 case MULTIPLY:
392 case DIVIDE:
393 case LPAREN:
394 case IDENT:
395 case STRING_LITERAL:
396 case NUM_INT:
397 case NUM_FLOAT:
398 case LITERAL_false:
399 case LITERAL_true:
400 {
401 expr=expression(_t);
402 _t = _retTree;
403 break;
404 }
405 case LITERAL_is:
406 case LITERAL_between:
407 case LITERAL_in:
408 case LITERAL_like:
409 {
410 expr=booleanExpression(_t);
411 _t = _retTree;
412 break;
413 }
414 default:
415 {
416 throw new NoViableAltException(_t);
417 }
418 }
419 _retTree = _t;
420 return expr;
421 }
422
423 public final Expression expression(AST _t) throws RecognitionException {
424 Expression expr;
425
426 SelectorAST expression_AST_in = (SelectorAST)_t;
427 SelectorAST plusl = null;
428 SelectorAST plusr = null;
429 SelectorAST minusl = null;
430 SelectorAST minusr = null;
431 SelectorAST multl = null;
432 SelectorAST multr = null;
433 SelectorAST divl = null;
434 SelectorAST divr = null;
435
436 expr = null;
437 AST ast = expression_AST_in;
438 Expression lhs = null;
439 Expression rhs = null;
440
441
442 if (_t==null) _t=ASTNULL;
443 switch ( _t.getType()) {
444 case PLUS:
445 case MINUS:
446 case MULTIPLY:
447 case DIVIDE:
448 {
449 {
450 if (_t==null) _t=ASTNULL;
451 switch ( _t.getType()) {
452 case PLUS:
453 {
454 AST __t17 = _t;
455 SelectorAST tmp10_AST_in = (SelectorAST)_t;
456 match(_t,PLUS);
457 _t = _t.getFirstChild();
458 plusl = _t==ASTNULL ? null : (SelectorAST)_t;
459 lhs=expression(_t);
460 _t = _retTree;
461 plusr = _t==ASTNULL ? null : (SelectorAST)_t;
462 rhs=expression(_t);
463 _t = _retTree;
464 _t = __t17;
465 _t = _t.getNextSibling();
466
467 TypeChecker.check(ast.getText(), plusl, plusr, Type.NUMERIC);
468
469 break;
470 }
471 case MINUS:
472 {
473 AST __t18 = _t;
474 SelectorAST tmp11_AST_in = (SelectorAST)_t;
475 match(_t,MINUS);
476 _t = _t.getFirstChild();
477 minusl = _t==ASTNULL ? null : (SelectorAST)_t;
478 lhs=expression(_t);
479 _t = _retTree;
480 minusr = _t==ASTNULL ? null : (SelectorAST)_t;
481 rhs=expression(_t);
482 _t = _retTree;
483 _t = __t18;
484 _t = _t.getNextSibling();
485
486 TypeChecker.check(ast.getText(), minusl, minusr, Type.NUMERIC);
487
488 break;
489 }
490 case MULTIPLY:
491 {
492 AST __t19 = _t;
493 SelectorAST tmp12_AST_in = (SelectorAST)_t;
494 match(_t,MULTIPLY);
495 _t = _t.getFirstChild();
496 multl = _t==ASTNULL ? null : (SelectorAST)_t;
497 lhs=expression(_t);
498 _t = _retTree;
499 multr = _t==ASTNULL ? null : (SelectorAST)_t;
500 rhs=expression(_t);
501 _t = _retTree;
502 _t = __t19;
503 _t = _t.getNextSibling();
504
505 TypeChecker.check(ast.getText(), multl, multr, Type.NUMERIC);
506
507 break;
508 }
509 case DIVIDE:
510 {
511 AST __t20 = _t;
512 SelectorAST tmp13_AST_in = (SelectorAST)_t;
513 match(_t,DIVIDE);
514 _t = _t.getFirstChild();
515 divl = _t==ASTNULL ? null : (SelectorAST)_t;
516 lhs=expression(_t);
517 _t = _retTree;
518 divr = _t==ASTNULL ? null : (SelectorAST)_t;
519 rhs=expression(_t);
520 _t = _retTree;
521 _t = __t20;
522 _t = _t.getNextSibling();
523
524 TypeChecker.check(ast.getText(), divl, divr, Type.NUMERIC);
525
526 break;
527 }
528 default:
529 {
530 throw new NoViableAltException(_t);
531 }
532 }
533 }
534
535 expr = factory.binaryOperator(ast.getType(), lhs, rhs);
536
537 break;
538 }
539 case UNARY_MINUS:
540 case LPAREN:
541 case IDENT:
542 case STRING_LITERAL:
543 case NUM_INT:
544 case NUM_FLOAT:
545 case LITERAL_false:
546 case LITERAL_true:
547 {
548 expr=term(_t);
549 _t = _retTree;
550 break;
551 }
552 default:
553 {
554 throw new NoViableAltException(_t);
555 }
556 }
557 _retTree = _t;
558 return expr;
559 }
560
561 public final Expression booleanExpression(AST _t) throws RecognitionException {
562 Expression expr;
563
564 SelectorAST booleanExpression_AST_in = (SelectorAST)_t;
565
566 expr = null;
567
568
569 if (_t==null) _t=ASTNULL;
570 switch ( _t.getType()) {
571 case LITERAL_is:
572 {
573 expr=isExpression(_t);
574 _t = _retTree;
575 break;
576 }
577 case LITERAL_between:
578 {
579 expr=betweenExpression(_t);
580 _t = _retTree;
581 break;
582 }
583 case LITERAL_like:
584 {
585 expr=likeExpression(_t);
586 _t = _retTree;
587 break;
588 }
589 case LITERAL_in:
590 {
591 expr=inExpression(_t);
592 _t = _retTree;
593 break;
594 }
595 default:
596 {
597 throw new NoViableAltException(_t);
598 }
599 }
600 _retTree = _t;
601 return expr;
602 }
603
604 public final Expression term(AST _t) throws RecognitionException {
605 Expression expr;
606
607 SelectorAST term_AST_in = (SelectorAST)_t;
608 SelectorAST ident = null;
609
610 expr = null;
611
612
613 if (_t==null) _t=ASTNULL;
614 switch ( _t.getType()) {
615 case UNARY_MINUS:
616 {
617 AST __t35 = _t;
618 SelectorAST tmp14_AST_in = (SelectorAST)_t;
619 match(_t,UNARY_MINUS);
620 _t = _t.getFirstChild();
621 expr=unaryTerm(_t);
622 _t = _retTree;
623 _t = __t35;
624 _t = _t.getNextSibling();
625 break;
626 }
627 case LPAREN:
628 {
629 SelectorAST tmp15_AST_in = (SelectorAST)_t;
630 match(_t,LPAREN);
631 _t = _t.getNextSibling();
632 expr=primaryExpression(_t);
633 _t = _retTree;
634 SelectorAST tmp16_AST_in = (SelectorAST)_t;
635 match(_t,RPAREN);
636 _t = _t.getNextSibling();
637 break;
638 }
639 case IDENT:
640 {
641 ident = (SelectorAST)_t;
642 match(_t,IDENT);
643 _t = _t.getNextSibling();
644
645 expr = factory.identifier(ident.getText());
646
647 break;
648 }
649 case STRING_LITERAL:
650 case NUM_INT:
651 case NUM_FLOAT:
652 case LITERAL_false:
653 case LITERAL_true:
654 {
655 expr=literal(_t);
656 _t = _retTree;
657 break;
658 }
659 default:
660 {
661 throw new NoViableAltException(_t);
662 }
663 }
664 _retTree = _t;
665 return expr;
666 }
667
668 public final Expression isExpression(AST _t) throws RecognitionException {
669 Expression expr;
670
671 SelectorAST isExpression_AST_in = (SelectorAST)_t;
672 SelectorAST id = null;
673
674 expr = null;
675
676
677 AST __t23 = _t;
678 SelectorAST tmp17_AST_in = (SelectorAST)_t;
679 match(_t,LITERAL_is);
680 _t = _t.getFirstChild();
681 id = (SelectorAST)_t;
682 match(_t,IDENT);
683 _t = _t.getNextSibling();
684 SelectorAST tmp18_AST_in = (SelectorAST)_t;
685 match(_t,LITERAL_null);
686 _t = _t.getNextSibling();
687 _t = __t23;
688 _t = _t.getNextSibling();
689
690 Expression ident = factory.identifier(id.getText());
691 expr = factory.isNull(ident);
692
693 _retTree = _t;
694 return expr;
695 }
696
697 public final Expression betweenExpression(AST _t) throws RecognitionException {
698 Expression expr;
699
700 SelectorAST betweenExpression_AST_in = (SelectorAST)_t;
701 SelectorAST e = null;
702 SelectorAST s1 = null;
703 SelectorAST s2 = null;
704
705 expr = null;
706 Expression sum1 = null;
707 Expression sum2 = null;
708
709
710 AST __t25 = _t;
711 SelectorAST tmp19_AST_in = (SelectorAST)_t;
712 match(_t,LITERAL_between);
713 _t = _t.getFirstChild();
714 e = _t==ASTNULL ? null : (SelectorAST)_t;
715 expr=primaryExpression(_t);
716 _t = _retTree;
717 s1 = _t==ASTNULL ? null : (SelectorAST)_t;
718 sum1=primaryExpression(_t);
719 _t = _retTree;
720 s2 = _t==ASTNULL ? null : (SelectorAST)_t;
721 sum2=primaryExpression(_t);
722 _t = _retTree;
723 _t = __t25;
724 _t = _t.getNextSibling();
725
726 TypeChecker.check(e, Type.NUMERIC);
727 TypeChecker.check(s1, Type.NUMERIC);
728 TypeChecker.check(s2, Type.NUMERIC);
729 expr = factory.between(expr, sum1, sum2);
730
731 _retTree = _t;
732 return expr;
733 }
734
735 public final Expression likeExpression(AST _t) throws RecognitionException {
736 Expression expr;
737
738 SelectorAST likeExpression_AST_in = (SelectorAST)_t;
739 SelectorAST id = null;
740 SelectorAST pat = null;
741 SelectorAST esc = null;
742
743 expr = null;
744
745
746 AST __t27 = _t;
747 SelectorAST tmp20_AST_in = (SelectorAST)_t;
748 match(_t,LITERAL_like);
749 _t = _t.getFirstChild();
750 id = (SelectorAST)_t;
751 match(_t,IDENT);
752 _t = _t.getNextSibling();
753 pat = (SelectorAST)_t;
754 match(_t,STRING_LITERAL);
755 _t = _t.getNextSibling();
756 {
757 if (_t==null) _t=ASTNULL;
758 switch ( _t.getType()) {
759 case LITERAL_escape:
760 {
761 SelectorAST tmp21_AST_in = (SelectorAST)_t;
762 match(_t,LITERAL_escape);
763 _t = _t.getNextSibling();
764 esc = (SelectorAST)_t;
765 match(_t,STRING_LITERAL);
766 _t = _t.getNextSibling();
767 break;
768 }
769 case 3:
770 {
771 break;
772 }
773 default:
774 {
775 throw new NoViableAltException(_t);
776 }
777 }
778 }
779 _t = __t27;
780 _t = _t.getNextSibling();
781
782 TypeChecker.check(id, Type.STRING);
783 PatternValidator.validate(pat, esc);
784
785 Expression ident = factory.identifier(id.getText());
786 String escape = (esc != null) ? esc.getText() : null;
787 expr = factory.like(ident, pat.getText(), escape);
788
789 _retTree = _t;
790 return expr;
791 }
792
793 public final Expression inExpression(AST _t) throws RecognitionException {
794 Expression expr;
795
796 SelectorAST inExpression_AST_in = (SelectorAST)_t;
797 SelectorAST id = null;
798
799 expr = null;
800 HashSet set;
801
802
803 AST __t30 = _t;
804 SelectorAST tmp22_AST_in = (SelectorAST)_t;
805 match(_t,LITERAL_in);
806 _t = _t.getFirstChild();
807 id = (SelectorAST)_t;
808 match(_t,IDENT);
809 _t = _t.getNextSibling();
810 SelectorAST tmp23_AST_in = (SelectorAST)_t;
811 match(_t,LPAREN);
812 _t = _t.getNextSibling();
813 set=valueList(_t);
814 _t = _retTree;
815 SelectorAST tmp24_AST_in = (SelectorAST)_t;
816 match(_t,RPAREN);
817 _t = _t.getNextSibling();
818 _t = __t30;
819 _t = _t.getNextSibling();
820
821 TypeChecker.check(id, Type.STRING);
822
823 Expression ident = factory.identifier(id.getText());
824 expr = factory.in(ident, set);
825
826 _retTree = _t;
827 return expr;
828 }
829
830 public final HashSet valueList(AST _t) throws RecognitionException {
831 HashSet set;
832
833 SelectorAST valueList_AST_in = (SelectorAST)_t;
834 SelectorAST first = null;
835 SelectorAST next = null;
836
837 set = new HashSet ();
838
839
840 first = (SelectorAST)_t;
841 match(_t,STRING_LITERAL);
842 _t = _t.getNextSibling();
843 set.add(first.getText());
844 {
845 _loop33:
846 do {
847 if (_t==null) _t=ASTNULL;
848 if ((_t.getType()==STRING_LITERAL)) {
849 next = (SelectorAST)_t;
850 match(_t,STRING_LITERAL);
851 _t = _t.getNextSibling();
852 set.add(next.getText());
853 }
854 else {
855 break _loop33;
856 }
857
858 } while (true);
859 }
860 _retTree = _t;
861 return set;
862 }
863
864 public final Expression unaryTerm(AST _t) throws RecognitionException {
865 Expression expr;
866
867 SelectorAST unaryTerm_AST_in = (SelectorAST)_t;
868 SelectorAST minus = null;
869 SelectorAST term = null;
870 SelectorAST primary = null;
871
872 expr = null;
873 SelectorAST ast = unaryTerm_AST_in;
874
875
876 if (_t==null) _t=ASTNULL;
877 switch ( _t.getType()) {
878 case UNARY_MINUS:
879 {
880 AST __t37 = _t;
881 minus = _t==ASTNULL ? null :(SelectorAST)_t;
882 match(_t,UNARY_MINUS);
883 _t = _t.getFirstChild();
884 term = _t==ASTNULL ? null : (SelectorAST)_t;
885 expr=term(_t);
886 _t = _retTree;
887 _t = __t37;
888 _t = _t.getNextSibling();
889
890 TypeChecker.check(ast.getText(), term, Type.NUMERIC);
891
892 break;
893 }
894 case LPAREN:
895 {
896 SelectorAST tmp25_AST_in = (SelectorAST)_t;
897 match(_t,LPAREN);
898 _t = _t.getNextSibling();
899 primary = _t==ASTNULL ? null : (SelectorAST)_t;
900 expr=primaryExpression(_t);
901 _t = _retTree;
902 SelectorAST tmp26_AST_in = (SelectorAST)_t;
903 match(_t,RPAREN);
904 _t = _t.getNextSibling();
905
906 TypeChecker.check(primary.getText(), primary, Type.NUMERIC);
907 expr = factory.unaryOperator(SelectorTokenTypes.UNARY_MINUS,
908 expr);
909
910 break;
911 }
912 case IDENT:
913 {
914 SelectorAST tmp27_AST_in = (SelectorAST)_t;
915 match(_t,IDENT);
916 _t = _t.getNextSibling();
917
918 expr = factory.identifier(ast.getText());
919 TypeChecker.check(ast.getText(), ast, Type.NUMERIC);
920 expr = factory.unaryOperator(SelectorTokenTypes.UNARY_MINUS,
921 expr);
922
923 break;
924 }
925 case NUM_INT:
926 case NUM_FLOAT:
927 {
928 {
929 if (_t==null) _t=ASTNULL;
930 switch ( _t.getType()) {
931 case NUM_INT:
932 {
933 SelectorAST tmp28_AST_in = (SelectorAST)_t;
934 match(_t,NUM_INT);
935 _t = _t.getNextSibling();
936 break;
937 }
938 case NUM_FLOAT:
939 {
940 SelectorAST tmp29_AST_in = (SelectorAST)_t;
941 match(_t,NUM_FLOAT);
942 _t = _t.getNextSibling();
943 break;
944 }
945 default:
946 {
947 throw new NoViableAltException(_t);
948 }
949 }
950 }
951
952 expr = factory.literal(ast.getType(), "-" + ast.getText());
953
954 break;
955 }
956 default:
957 {
958 throw new NoViableAltException(_t);
959 }
960 }
961 _retTree = _t;
962 return expr;
963 }
964
965 public final Expression literal(AST _t) throws RecognitionException {
966 Expression expr;
967
968 SelectorAST literal_AST_in = (SelectorAST)_t;
969
970 expr = null;
971 AST ast = literal_AST_in;
972
973
974 {
975 if (_t==null) _t=ASTNULL;
976 switch ( _t.getType()) {
977 case NUM_INT:
978 {
979 SelectorAST tmp30_AST_in = (SelectorAST)_t;
980 match(_t,NUM_INT);
981 _t = _t.getNextSibling();
982 break;
983 }
984 case NUM_FLOAT:
985 {
986 SelectorAST tmp31_AST_in = (SelectorAST)_t;
987 match(_t,NUM_FLOAT);
988 _t = _t.getNextSibling();
989 break;
990 }
991 case STRING_LITERAL:
992 {
993 SelectorAST tmp32_AST_in = (SelectorAST)_t;
994 match(_t,STRING_LITERAL);
995 _t = _t.getNextSibling();
996 break;
997 }
998 case LITERAL_false:
999 {
1000 SelectorAST tmp33_AST_in = (SelectorAST)_t;
1001 match(_t,LITERAL_false);
1002 _t = _t.getNextSibling();
1003 break;
1004 }
1005 case LITERAL_true:
1006 {
1007 SelectorAST tmp34_AST_in = (SelectorAST)_t;
1008 match(_t,LITERAL_true);
1009 _t = _t.getNextSibling();
1010 break;
1011 }
1012 default:
1013 {
1014 throw new NoViableAltException(_t);
1015 }
1016 }
1017 }
1018
1019 expr = factory.literal(ast.getType(), ast.getText());
1020
1021 _retTree = _t;
1022 return expr;
1023 }
1024
1025
1026 public static final String [] _tokenNames = {
1027 "<0>",
1028 "EOF",
1029 "<2>",
1030 "NULL_TREE_LOOKAHEAD",
1031 "UNARY_MINUS",
1032 "\"or\"",
1033 "\"and\"",
1034 "\"not\"",
1035 "=",
1036 "<>",
1037 "<",
1038 ">",
1039 "<=",
1040 ">=",
1041 "+",
1042 "-",
1043 "*",
1044 "/",
1045 "(",
1046 ")",
1047 "an identifier",
1048 "\"is\"",
1049 "\"null\"",
1050 "\"between\"",
1051 "\"in\"",
1052 "\"like\"",
1053 "a string literal",
1054 "\"escape\"",
1055 ",",
1056 "an integer",
1057 "NUM_FLOAT",
1058 "\"false\"",
1059 "\"true\"",
1060 "WS",
1061 "HEX_DIGIT",
1062 "EXPONENT",
1063 "FLOAT_SUFFIX",
1064 "IDENT_START",
1065 "IDENT_NON_START",
1066 "IDENT_PART"
1067 };
1068
1069 }
1070
1071 |
Popular Tags |
Java API By Example, From Geeks To Geeks.