|
1
16
17
18 package org.apache.taglibs.standard.lang.jpath.expression;
19
20 import java.io.StringReader;
21
22 public class Parserimplements ParserTreeConstants, ParserConstants {
23 protected JJTParserState jjtree = new JJTParserState();public static Expression parse(String expressionText)
24 throws ParseException {
25 Parser parser;
26 Expression expression;
27 parser = new Parser(new StringReader(expressionText));
28 parser.Expression();
29 expression = (Expression)parser.jjtree.rootNode();
30 return expression;
31 }
32
33 void jjtreeOpenNodeScope(Node n) {
34 ((SimpleNode)n).firstToken = getToken(0);
35 }
36
37 void jjtreeCloseNodeScope(Node n) {
38 ((SimpleNode)n).lastToken = getToken(0);
39 }
40
41
44 final public void Expression() throws ParseException {
45
46 Expression jjtn000 = new Expression(JJTEXPRESSION);
47 boolean jjtc000 = true;
48 jjtree.openNodeScope(jjtn000);
49 jjtreeOpenNodeScope(jjtn000);
50 try {
51 Expr();
52 jj_consume_token(0);
53 } catch (Throwable jjte000) {
54 if (jjtc000) {
55 jjtree.clearNodeScope(jjtn000);
56 jjtc000 = false;
57 } else {
58 jjtree.popNode();
59 }
60 if (jjte000 instanceof RuntimeException) {
61 {if (true) throw (RuntimeException)jjte000;}
62 }
63 if (jjte000 instanceof ParseException) {
64 {if (true) throw (ParseException)jjte000;}
65 }
66 {if (true) throw (Error)jjte000;}
67 } finally {
68 if (jjtc000) {
69 jjtree.closeNodeScope(jjtn000, 1);
70 jjtreeCloseNodeScope(jjtn000);
71 }
72 }
73 }
74
75
76 final public void Expr() throws ParseException {
77 OrExpr();
78 }
79
80
81 final public void OrExpr() throws ParseException {
82 AndExpr();
83 label_1:
84 while (true) {
85 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
86 case OR:
87 ;
88 break;
89 default:
90 jj_la1[0] = jj_gen;
91 break label_1;
92 }
93 jj_consume_token(OR);
94 OrOperator jjtn001 = new OrOperator(JJTOROPERATOR);
95 boolean jjtc001 = true;
96 jjtree.openNodeScope(jjtn001);
97 jjtreeOpenNodeScope(jjtn001);
98 try {
99 AndExpr();
100 } catch (Throwable jjte001) {
101 if (jjtc001) {
102 jjtree.clearNodeScope(jjtn001);
103 jjtc001 = false;
104 } else {
105 jjtree.popNode();
106 }
107 if (jjte001 instanceof RuntimeException) {
108 {if (true) throw (RuntimeException)jjte001;}
109 }
110 if (jjte001 instanceof ParseException) {
111 {if (true) throw (ParseException)jjte001;}
112 }
113 {if (true) throw (Error)jjte001;}
114 } finally {
115 if (jjtc001) {
116 jjtree.closeNodeScope(jjtn001, 2);
117 jjtreeCloseNodeScope(jjtn001);
118 }
119 }
120 }
121 }
122
123
124 final public void AndExpr() throws ParseException {
125 EqualityExpr();
126 label_2:
127 while (true) {
128 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
129 case AND:
130 ;
131 break;
132 default:
133 jj_la1[1] = jj_gen;
134 break label_2;
135 }
136 jj_consume_token(AND);
137 AndOperator jjtn001 = new AndOperator(JJTANDOPERATOR);
138 boolean jjtc001 = true;
139 jjtree.openNodeScope(jjtn001);
140 jjtreeOpenNodeScope(jjtn001);
141 try {
142 EqualityExpr();
143 } catch (Throwable jjte001) {
144 if (jjtc001) {
145 jjtree.clearNodeScope(jjtn001);
146 jjtc001 = false;
147 } else {
148 jjtree.popNode();
149 }
150 if (jjte001 instanceof RuntimeException) {
151 {if (true) throw (RuntimeException)jjte001;}
152 }
153 if (jjte001 instanceof ParseException) {
154 {if (true) throw (ParseException)jjte001;}
155 }
156 {if (true) throw (Error)jjte001;}
157 } finally {
158 if (jjtc001) {
159 jjtree.closeNodeScope(jjtn001, 2);
160 jjtreeCloseNodeScope(jjtn001);
161 }
162 }
163 }
164 }
165
166
167 final public void EqualityExpr() throws ParseException {
168 RelationalExpr();
169 label_3:
170 while (true) {
171 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
172 case EQ:
173 case NEQ:
174 ;
175 break;
176 default:
177 jj_la1[2] = jj_gen;
178 break label_3;
179 }
180 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
181 case EQ:
182 jj_consume_token(EQ);
183 EqualsOperator jjtn001 = new EqualsOperator(JJTEQUALSOPERATOR);
184 boolean jjtc001 = true;
185 jjtree.openNodeScope(jjtn001);
186 jjtreeOpenNodeScope(jjtn001);
187 try {
188 RelationalExpr();
189 } catch (Throwable jjte001) {
190 if (jjtc001) {
191 jjtree.clearNodeScope(jjtn001);
192 jjtc001 = false;
193 } else {
194 jjtree.popNode();
195 }
196 if (jjte001 instanceof RuntimeException) {
197 {if (true) throw (RuntimeException)jjte001;}
198 }
199 if (jjte001 instanceof ParseException) {
200 {if (true) throw (ParseException)jjte001;}
201 }
202 {if (true) throw (Error)jjte001;}
203 } finally {
204 if (jjtc001) {
205 jjtree.closeNodeScope(jjtn001, 2);
206 jjtreeCloseNodeScope(jjtn001);
207 }
208 }
209 break;
210 case NEQ:
211 jj_consume_token(NEQ);
212 NotEqualsOperator jjtn002 = new NotEqualsOperator(JJTNOTEQUALSOPERATOR);
213 boolean jjtc002 = true;
214 jjtree.openNodeScope(jjtn002);
215 jjtreeOpenNodeScope(jjtn002);
216 try {
217 RelationalExpr();
218 } catch (Throwable jjte002) {
219 if (jjtc002) {
220 jjtree.clearNodeScope(jjtn002);
221 jjtc002 = false;
222 } else {
223 jjtree.popNode();
224 }
225 if (jjte002 instanceof RuntimeException) {
226 {if (true) throw (RuntimeException)jjte002;}
227 }
228 if (jjte002 instanceof ParseException) {
229 {if (true) throw (ParseException)jjte002;}
230 }
231 {if (true) throw (Error)jjte002;}
232 } finally {
233 if (jjtc002) {
234 jjtree.closeNodeScope(jjtn002, 2);
235 jjtreeCloseNodeScope(jjtn002);
236 }
237 }
238 break;
239 default:
240 jj_la1[3] = jj_gen;
241 jj_consume_token(-1);
242 throw new ParseException();
243 }
244 }
245 }
246
247
248 final public void RelationalExpr() throws ParseException {
249 AdditiveExpr();
250 label_4:
251 while (true) {
252 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
253 case LT:
254 case LTE:
255 case GT:
256 case GTE:
257 ;
258 break;
259 default:
260 jj_la1[4] = jj_gen;
261 break label_4;
262 }
263 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
264 case LT:
265 jj_consume_token(LT);
266 LessThanOperator jjtn001 = new LessThanOperator(JJTLESSTHANOPERATOR);
267 boolean jjtc001 = true;
268 jjtree.openNodeScope(jjtn001);
269 jjtreeOpenNodeScope(jjtn001);
270 try {
271 AdditiveExpr();
272 } catch (Throwable jjte001) {
273 if (jjtc001) {
274 jjtree.clearNodeScope(jjtn001);
275 jjtc001 = false;
276 } else {
277 jjtree.popNode();
278 }
279 if (jjte001 instanceof RuntimeException) {
280 {if (true) throw (RuntimeException)jjte001;}
281 }
282 if (jjte001 instanceof ParseException) {
283 {if (true) throw (ParseException)jjte001;}
284 }
285 {if (true) throw (Error)jjte001;}
286 } finally {
287 if (jjtc001) {
288 jjtree.closeNodeScope(jjtn001, 2);
289 jjtreeCloseNodeScope(jjtn001);
290 }
291 }
292 break;
293 case GT:
294 jj_consume_token(GT);
295 GreaterThanOperator jjtn002 = new GreaterThanOperator(JJTGREATERTHANOPERATOR);
296 boolean jjtc002 = true;
297 jjtree.openNodeScope(jjtn002);
298 jjtreeOpenNodeScope(jjtn002);
299 try {
300 AdditiveExpr();
301 } catch (Throwable jjte002) {
302 if (jjtc002) {
303 jjtree.clearNodeScope(jjtn002);
304 jjtc002 = false;
305 } else {
306 jjtree.popNode();
307 }
308 if (jjte002 instanceof RuntimeException) {
309 {if (true) throw (RuntimeException)jjte002;}
310 }
311 if (jjte002 instanceof ParseException) {
312 {if (true) throw (ParseException)jjte002;}
313 }
314 {if (true) throw (Error)jjte002;}
315 } finally {
316 if (jjtc002) {
317 jjtree.closeNodeScope(jjtn002, 2);
318 jjtreeCloseNodeScope(jjtn002);
319 }
320 }
321 break;
322 case LTE:
323 jj_consume_token(LTE);
324 LessThanEqualOperator jjtn003 = new LessThanEqualOperator(JJTLESSTHANEQUALOPERATOR);
325 boolean jjtc003 = true;
326 jjtree.openNodeScope(jjtn003);
327 jjtreeOpenNodeScope(jjtn003);
328 try {
329 AdditiveExpr();
330 } catch (Throwable jjte003) {
331 if (jjtc003) {
332 jjtree.clearNodeScope(jjtn003);
333 jjtc003 = false;
334 } else {
335 jjtree.popNode();
336 }
337 if (jjte003 instanceof RuntimeException) {
338 {if (true) throw (RuntimeException)jjte003;}
339 }
340 if (jjte003 instanceof ParseException) {
341 {if (true) throw (ParseException)jjte003;}
342 }
343 {if (true) throw (Error)jjte003;}
344 } finally {
345 if (jjtc003) {
346 jjtree.closeNodeScope(jjtn003, 2);
347 jjtreeCloseNodeScope(jjtn003);
348 }
349 }
350 break;
351 case GTE:
352 jj_consume_token(GTE);
353 GreaterThanEqualOperator jjtn004 = new GreaterThanEqualOperator(JJTGREATERTHANEQUALOPERATOR);
354 boolean jjtc004 = true;
355 jjtree.openNodeScope(jjtn004);
356 jjtreeOpenNodeScope(jjtn004);
357 try {
358 AdditiveExpr();
359 } catch (Throwable jjte004) {
360 if (jjtc004) {
361 jjtree.clearNodeScope(jjtn004);
362 jjtc004 = false;
363 } else {
364 jjtree.popNode();
365 }
366 if (jjte004 instanceof RuntimeException) {
367 {if (true) throw (RuntimeException)jjte004;}
368 }
369 if (jjte004 instanceof ParseException) {
370 {if (true) throw (ParseException)jjte004;}
371 }
372 {if (true) throw (Error)jjte004;}
373 } finally {
374 if (jjtc004) {
375 jjtree.closeNodeScope(jjtn004, 2);
376 jjtreeCloseNodeScope(jjtn004);
377 }
378 }
379 break;
380 default:
381 jj_la1[5] = jj_gen;
382 jj_consume_token(-1);
383 throw new ParseException();
384 }
385 }
386 }
387
388
389 final public void AdditiveExpr() throws ParseException {
390 MultiplicativeExpr();
391 label_5:
392 while (true) {
393 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
394 case PLUS:
395 case MINUS:
396 ;
397 break;
398 default:
399 jj_la1[6] = jj_gen;
400 break label_5;
401 }
402 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
403 case PLUS:
404 jj_consume_token(PLUS);
405 AdditionOperator jjtn001 = new AdditionOperator(JJTADDITIONOPERATOR);
406 boolean jjtc001 = true;
407 jjtree.openNodeScope(jjtn001);
408 jjtreeOpenNodeScope(jjtn001);
409 try {
410 MultiplicativeExpr();
411 } catch (Throwable jjte001) {
412 if (jjtc001) {
413 jjtree.clearNodeScope(jjtn001);
414 jjtc001 = false;
415 } else {
416 jjtree.popNode();
417 }
418 if (jjte001 instanceof RuntimeException) {
419 {if (true) throw (RuntimeException)jjte001;}
420 }
421 if (jjte001 instanceof ParseException) {
422 {if (true) throw (ParseException)jjte001;}
423 }
424 {if (true) throw (Error)jjte001;}
425 } finally {
426 if (jjtc001) {
427 jjtree.closeNodeScope(jjtn001, 2);
428 jjtreeCloseNodeScope(jjtn001);
429 }
430 }
431 break;
432 case MINUS:
433 jj_consume_token(MINUS);
434 SubtractionOperator jjtn002 = new SubtractionOperator(JJTSUBTRACTIONOPERATOR);
435 boolean jjtc002 = true;
436 jjtree.openNodeScope(jjtn002);
437 jjtreeOpenNodeScope(jjtn002);
438 try {
439 MultiplicativeExpr();
440 } catch (Throwable jjte002) {
441 if (jjtc002) {
442 jjtree.clearNodeScope(jjtn002);
443 jjtc002 = false;
444 } else {
445 jjtree.popNode();
446 }
447 if (jjte002 instanceof RuntimeException) {
448 {if (true) throw (RuntimeException)jjte002;}
449 }
450 if (jjte002 instanceof ParseException) {
451 {if (true) throw (ParseException)jjte002;}
452 }
453 {if (true) throw (Error)jjte002;}
454 } finally {
455 if (jjtc002) {
456 jjtree.closeNodeScope(jjtn002, 2);
457 jjtreeCloseNodeScope(jjtn002);
458 }
459 }
460 break;
461 default:
462 jj_la1[7] = jj_gen;
463 jj_consume_token(-1);
464 throw new ParseException();
465 }
466 }
467 }
468
469
470 final public void MultiplicativeExpr() throws ParseException {
471 UnaryExpr();
472 label_6:
473 while (true) {
474 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
475 case DIV:
476 case MULT:
477 case MOD:
478 ;
479 break;
480 default:
481 jj_la1[8] = jj_gen;
482 break label_6;
483 }
484 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
485 case MULT:
486 jj_consume_token(MULT);
487 MultiplicationOperator jjtn001 = new MultiplicationOperator(JJTMULTIPLICATIONOPERATOR);
488 boolean jjtc001 = true;
489 jjtree.openNodeScope(jjtn001);
490 jjtreeOpenNodeScope(jjtn001);
491 try {
492 UnaryExpr();
493 } catch (Throwable jjte001) {
494 if (jjtc001) {
495 jjtree.clearNodeScope(jjtn001);
496 jjtc001 = false;
497 } else {
498 jjtree.popNode();
499 }
500 if (jjte001 instanceof RuntimeException) {
501 {if (true) throw (RuntimeException)jjte001;}
502 }
503 if (jjte001 instanceof ParseException) {
504 {if (true) throw (ParseException)jjte001;}
505 }
506 {if (true) throw (Error)jjte001;}
507 } finally {
508 if (jjtc001) {
509 jjtree.closeNodeScope(jjtn001, 2);
510 jjtreeCloseNodeScope(jjtn001);
511 }
512 }
513 break;
514 case DIV:
515 jj_consume_token(DIV);
516 DivisionOperator jjtn002 = new DivisionOperator(JJTDIVISIONOPERATOR);
517 boolean jjtc002 = true;
518 jjtree.openNodeScope(jjtn002);
519 jjtreeOpenNodeScope(jjtn002);
520 try {
521 UnaryExpr();
522 } catch (Throwable jjte002) {
523 if (jjtc002) {
524 jjtree.clearNodeScope(jjtn002);
525 jjtc002 = false;
526 } else {
527 jjtree.popNode();
528 }
529 if (jjte002 instanceof RuntimeException) {
530 {if (true) throw (RuntimeException)jjte002;}
531 }
532 if (jjte002 instanceof ParseException) {
533 {if (true) throw (ParseException)jjte002;}
534 }
535 {if (true) throw (Error)jjte002;}
536 } finally {
537 if (jjtc002) {
538 jjtree.closeNodeScope(jjtn002, 2);
539 jjtreeCloseNodeScope(jjtn002);
540 }
541 }
542 break;
543 case MOD:
544 jj_consume_token(MOD);
545 ModulusOperator jjtn003 = new ModulusOperator(JJTMODULUSOPERATOR);
546 boolean jjtc003 = true;
547 jjtree.openNodeScope(jjtn003);
548 jjtreeOpenNodeScope(jjtn003);
549 try {
550 UnaryExpr();
551 } catch (Throwable jjte003) {
552 if (jjtc003) {
553 jjtree.clearNodeScope(jjtn003);
554 jjtc003 = false;
555 } else {
556 jjtree.popNode();
557 }
558 if (jjte003 instanceof RuntimeException) {
559 {if (true) throw (RuntimeException)jjte003;}
560 }
561 if (jjte003 instanceof ParseException) {
562 {if (true) throw (ParseException)jjte003;}
563 }
564 {if (true) throw (Error)jjte003;}
565 } finally {
566 if (jjtc003) {
567 jjtree.closeNodeScope(jjtn003, 2);
568 jjtreeCloseNodeScope(jjtn003);
569 }
570 }
571 break;
572 default:
573 jj_la1[9] = jj_gen;
574 jj_consume_token(-1);
575 throw new ParseException();
576 }
577 }
578 }
579
580
581 final public void UnaryExpr() throws ParseException {
582 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
583 case LIST_BEGIN:
584 case FUNCTION_BEGIN:
585 case 29:
586 case 30:
587 case 31:
588 case 32:
589 case 33:
590 case 34:
591 case 35:
592 case 36:
593 case 37:
594 case 38:
595 case 39:
596 case 40:
597 case 41:
598 case 42:
599 case 43:
600 case 44:
601 case 45:
602 case 46:
603 case 47:
604 case 48:
605 case 49:
606 case 50:
607 case 51:
608 case 52:
609 case 53:
610 case 54:
611 case 55:
612 case 56:
613 case 57:
614 case SCOPE_LIMIT_NAME:
615 case BOOLEAN_LITERAL:
616 case STRING_LITERAL:
617 case NUMBER_LITERAL:
618 case IDENTIFIER:
619 UnionExpr();
620 break;
621 case MINUS:
622 jj_consume_token(MINUS);
623 UnaryExpr();
624 break;
625 default:
626 jj_la1[10] = jj_gen;
627 jj_consume_token(-1);
628 throw new ParseException();
629 }
630 }
631
632
633 final public void UnionExpr() throws ParseException {
634 IntrospectiveExpr();
635 label_7:
636 while (true) {
637 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
638 case UNION:
639 ;
640 break;
641 default:
642 jj_la1[11] = jj_gen;
643 break label_7;
644 }
645 jj_consume_token(UNION);
646 UnionOperator jjtn001 = new UnionOperator(JJTUNIONOPERATOR);
647 boolean jjtc001 = true;
648 jjtree.openNodeScope(jjtn001);
649 jjtreeOpenNodeScope(jjtn001);
650 try {
651 IntrospectiveExpr();
652 } catch (Throwable jjte001) {
653 if (jjtc001) {
654 jjtree.clearNodeScope(jjtn001);
655 jjtc001 = false;
656 } else {
657 jjtree.popNode();
658 }
659 if (jjte001 instanceof RuntimeException) {
660 {if (true) throw (RuntimeException)jjte001;}
661 }
662 if (jjte001 instanceof ParseException) {
663 {if (true) throw (ParseException)jjte001;}
664 }
665 {if (true) throw (Error)jjte001;}
666 } finally {
667 if (jjtc001) {
668 jjtree.closeNodeScope(jjtn001, 2);
669 jjtreeCloseNodeScope(jjtn001);
670 }
671 }
672 }
673 }
674
675
676 final public void IntrospectiveExpr() throws ParseException {
677 PathExpr();
678 label_8:
679 while (true) {
680 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
681 case INTROSPECT:
682 ;
683 break;
684 default:
685 jj_la1[12] = jj_gen;
686 break label_8;
687 }
688 jj_consume_token(INTROSPECT);
689 IntrospectionOperator jjtn001 = new IntrospectionOperator(JJTINTROSPECTIONOPERATOR);
690 boolean jjtc001 = true;
691 jjtree.openNodeScope(jjtn001);
692 jjtreeOpenNodeScope(jjtn001);
693 try {
694 PathExpr();
695 } catch (Throwable jjte001) {
696 if (jjtc001) {
697 jjtree.clearNodeScope(jjtn001);
698 jjtc001 = false;
699 } else {
700 jjtree.popNode();
701 }
702 if (jjte001 instanceof RuntimeException) {
703 {if (true) throw (RuntimeException)jjte001;}
704 }
705 if (jjte001 instanceof ParseException) {
706 {if (true) throw (ParseException)jjte001;}
707 }
708 {if (true) throw (Error)jjte001;}
709 } finally {
710 if (jjtc001) {
711 jjtree.closeNodeScope(jjtn001, 2);
712 jjtreeCloseNodeScope(jjtn001);
713 }
714 }
715 }
716 }
717
718
719 final public void PathExpr() throws ParseException {
720 FilterExpr();
721 }
722
723
724 final public void FilterExpr() throws ParseException {
725 PrimaryExpr();
726 label_9:
727 while (true) {
728 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
729 case PREDICATE_BEGIN:
730 ;
731 break;
732 default:
733 jj_la1[13] = jj_gen;
734 break label_9;
735 }
736 FilterOperator jjtn001 = new FilterOperator(JJTFILTEROPERATOR);
737 boolean jjtc001 = true;
738 jjtree.openNodeScope(jjtn001);
739 jjtreeOpenNodeScope(jjtn001);
740 try {
741 Predicate();
742 } catch (Throwable jjte001) {
743 if (jjtc001) {
744 jjtree.clearNodeScope(jjtn001);
745 jjtc001 = false;
746 } else {
747 jjtree.popNode();
748 }
749 if (jjte001 instanceof RuntimeException) {
750 {if (true) throw (RuntimeException)jjte001;}
751 }
752 if (jjte001 instanceof ParseException) {
753 {if (true) throw (ParseException)jjte001;}
754 }
755 {if (true) throw (Error)jjte001;}
756 } finally {
757 if (jjtc001) {
758 jjtree.closeNodeScope(jjtn001, 2);
759 jjtreeCloseNodeScope(jjtn001);
760 }
761 }
762 }
763 }
764
765
766 final public void Predicate() throws ParseException {
767
768 Predicate jjtn000 = new Predicate(JJTPREDICATE);
769 boolean jjtc000 = true;
770 jjtree.openNodeScope(jjtn000);
771 jjtreeOpenNodeScope(jjtn000);
772 try {
773 jj_consume_token(PREDICATE_BEGIN);
774 PredicateExpr();
775 jj_consume_token(PREDICATE_END);
776 } catch (Throwable jjte000) {
777 if (jjtc000) {
778 jjtree.clearNodeScope(jjtn000);
779 jjtc000 = false;
780 } else {
781 jjtree.popNode();
782 }
783 if (jjte000 instanceof RuntimeException) {
784 {if (true) throw (RuntimeException)jjte000;}
785 }
786 if (jjte000 instanceof ParseException) {
787 {if (true) throw (ParseException)jjte000;}
788 }
789 {if (true) throw (Error)jjte000;}
790 } finally {
791 if (jjtc000) {
792 jjtree.closeNodeScope(jjtn000, 1);
793 jjtreeCloseNodeScope(jjtn000);
794 }
795 }
796 }
797
798
799 final public void PredicateExpr() throws ParseException {
800 Expr();
801 }
802
803
804 final public void PrimaryExpr() throws ParseException {
805 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
806 case LIST_BEGIN:
807 case BOOLEAN_LITERAL:
808 case STRING_LITERAL:
809 case NUMBER_LITERAL:
810 Literal();
811 break;
812 case FUNCTION_BEGIN:
813 jj_consume_token(FUNCTION_BEGIN);
814 Expr();
815 jj_consume_token(FUNCTION_END);
816 break;
817 default:
818 jj_la1[14] = jj_gen;
819 if (jj_2_1(2)) {
820 Function();
821 } else {
822 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
823 case SCOPE_LIMIT_NAME:
824 ScopeLimitExpr();
825 break;
826 default:
827 jj_la1[15] = jj_gen;
828 if (jj_2_2(2)) {
829 Identifier();
830 } else {
831 jj_consume_token(-1);
832 throw new ParseException();
833 }
834 }
835 }
836 }
837 }
838
839
840
841 final public void Function() throws ParseException {
842 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
843 case 29:
844 jj_consume_token(29);
845 Argument();
846 BooleanFunction jjtn001 = new BooleanFunction(JJTBOOLEANFUNCTION);
847 boolean jjtc001 = true;
848 jjtree.openNodeScope(jjtn001);
849 jjtreeOpenNodeScope(jjtn001);
850 try {
851 jj_consume_token(FUNCTION_END);
852 } finally {
853 if (jjtc001) {
854 jjtree.closeNodeScope(jjtn001, 1);
855 jjtreeCloseNodeScope(jjtn001);
856 }
857 }
858 break;
859 case 30:
860 jj_consume_token(30);
861 Argument();
862 NumberFunction jjtn002 = new NumberFunction(JJTNUMBERFUNCTION);
863 boolean jjtc002 = true;
864 jjtree.openNodeScope(jjtn002);
865 jjtreeOpenNodeScope(jjtn002);
866 try {
867 jj_consume_token(FUNCTION_END);
868 } finally {
869 if (jjtc002) {
870 jjtree.closeNodeScope(jjtn002, 1);
871 jjtreeCloseNodeScope(jjtn002);
872 }
873 }
874 break;
875 case 31:
876 jj_consume_token(31);
877 Argument();
878 StringFunction jjtn003 = new StringFunction(JJTSTRINGFUNCTION);
879 boolean jjtc003 = true;
880 jjtree.openNodeScope(jjtn003);
881 jjtreeOpenNodeScope(jjtn003);
882 try {
883 jj_consume_token(FUNCTION_END);
884 } finally {
885 if (jjtc003) {
886 jjtree.closeNodeScope(jjtn003, 1);
887 jjtreeCloseNodeScope(jjtn003);
888 }
889 }
890 break;
891 case 32:
892 jj_consume_token(32);
893 Argument();
894 NotFunction jjtn004 = new NotFunction(JJTNOTFUNCTION);
895 boolean jjtc004 = true;
896 jjtree.openNodeScope(jjtn004);
897 jjtreeOpenNodeScope(jjtn004);
898 try {
899 jj_consume_token(FUNCTION_END);
900 } finally {
901 if (jjtc004) {
902 jjtree.closeNodeScope(jjtn004, 1);
903 jjtreeCloseNodeScope(jjtn004);
904 }
905 }
906 break;
907 case 33:
908 jj_consume_token(33);
909 Argument();
910 FloorFunction jjtn005 = new FloorFunction(JJTFLOORFUNCTION);
911 boolean jjtc005 = true;
912 jjtree.openNodeScope(jjtn005);
913 jjtreeOpenNodeScope(jjtn005);
914 try {
915 jj_consume_token(FUNCTION_END);
916 } finally {
917 if (jjtc005) {
918 jjtree.closeNodeScope(jjtn005, 1);
919 jjtreeCloseNodeScope(jjtn005);
920 }
921 }
922 break;
923 case 34:
924 jj_consume_token(34);
925 Argument();
926 CeilingFunction jjtn006 = new CeilingFunction(JJTCEILINGFUNCTION);
927 boolean jjtc006 = true;
928 jjtree.openNodeScope(jjtn006);
929 jjtreeOpenNodeScope(jjtn006);
930 try {
931 jj_consume_token(FUNCTION_END);
932 } finally {
933 if (jjtc006) {
934 jjtree.closeNodeScope(jjtn006, 1);
935 jjtreeCloseNodeScope(jjtn006);
936 }
937 }
938 break;
939 case 35:
940 jj_consume_token(35);
941 Argument();
942 RoundFunction jjtn007 = new RoundFunction(JJTROUNDFUNCTION);
943 boolean jjtc007 = true;
944 jjtree.openNodeScope(jjtn007);
945 jjtreeOpenNodeScope(jjtn007);
946 try {
947 jj_consume_token(FUNCTION_END);
948 } finally {
949 if (jjtc007) {
950 jjtree.closeNodeScope(jjtn007, 1);
951 jjtreeCloseNodeScope(jjtn007);
952 }
953 }
954 break;
955 case 36:
956 FormatNumberFunction jjtn008 = new FormatNumberFunction(JJTFORMATNUMBERFUNCTION);
957 boolean jjtc008 = true;
958 jjtree.openNodeScope(jjtn008);
959 jjtreeOpenNodeScope(jjtn008);
960 try {
961 jj_consume_token(36);
962 Argument();
963 jj_consume_token(SEPARATOR);
964 Argument();
965 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
966 case SEPARATOR:
967 jj_consume_token(SEPARATOR);
968 Argument();
969 break;
970 default:
971 jj_la1[16] = jj_gen;
972 ;
973 }
974 jj_consume_token(FUNCTION_END);
975 } catch (Throwable jjte008) {
976 if (jjtc008) {
977 jjtree.clearNodeScope(jjtn008);
978 jjtc008 = false;
979 } else {
980 jjtree.popNode();
981 }
982 if (jjte008 instanceof RuntimeException) {
983 {if (true) throw (RuntimeException)jjte008;}
984 }
985 if (jjte008 instanceof ParseException) {
986 {if (true) throw (ParseException)jjte008;}
987 }
988 {if (true) throw (Error)jjte008;}
989 } finally {
990 if (jjtc008) {
991 jjtree.closeNodeScope(jjtn008, jjtree.nodeArity() > 1);
992 jjtreeCloseNodeScope(jjtn008);
993 }
994 }
995 break;
996 case 37:
997 ConcatFunction jjtn009 = new ConcatFunction(JJTCONCATFUNCTION);
998 boolean jjtc009 = true;
999 jjtree.openNodeScope(jjtn009);
1000 jjtreeOpenNodeScope(jjtn009);
1001 try {
1002 jj_consume_token(37);
1003 Argument();
1004 label_10:
1005 while (true) {
1006 jj_consume_token(SEPARATOR);
1007 Argument();
1008 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1009 case SEPARATOR:
1010 ;
1011 break;
1012 default:
1013 jj_la1[17] = jj_gen;
1014 break label_10;
1015 }
1016 }
1017 jj_consume_token(FUNCTION_END);
1018 } catch (Throwable jjte009) {
1019 if (jjtc009) {
1020 jjtree.clearNodeScope(jjtn009);
1021 jjtc009 = false;
1022 } else {
1023 jjtree.popNode();
1024 }
1025 if (jjte009 instanceof RuntimeException) {
1026 {if (true) throw (RuntimeException)jjte009;}
1027 }
1028 if (jjte009 instanceof ParseException) {
1029 {if (true) throw (ParseException)jjte009;}
1030 }
1031 {if (true) throw (Error)jjte009;}
1032 } finally {
1033 if (jjtc009) {
1034 jjtree.closeNodeScope(jjtn009, jjtree.nodeArity() > 1);
1035 jjtreeCloseNodeScope(jjtn009);
1036 }
1037 }
1038 break;
1039 case 38:
1040 jj_consume_token(38);
1041 Argument();
1042 EncodeUrlFunction jjtn010 = new EncodeUrlFunction(JJTENCODEURLFUNCTION);
1043 boolean jjtc010 = true;
1044 jjtree.openNodeScope(jjtn010);
1045 jjtreeOpenNodeScope(jjtn010);
1046 try {
1047 jj_consume_token(FUNCTION_END);
1048 } finally {
1049 if (jjtc010) {
1050 jjtree.closeNodeScope(jjtn010, 1);
1051 jjtreeCloseNodeScope(jjtn010);
1052 }
1053 }
1054 break;
1055 case 39:
1056 jj_consume_token(39);
1057 Argument();
1058 EncodeHtmlFunction jjtn011 = new EncodeHtmlFunction(JJTENCODEHTMLFUNCTION);
1059 boolean jjtc011 = true;
1060 jjtree.openNodeScope(jjtn011);
1061 jjtreeOpenNodeScope(jjtn011);
1062 try {
1063 jj_consume_token(FUNCTION_END);
1064 } finally {
1065 if (jjtc011) {
1066 jjtree.closeNodeScope(jjtn011, 1);
1067 jjtreeCloseNodeScope(jjtn011);
1068 }
1069 }
1070 break;
1071 case 40:
1072 jj_consume_token(40);
1073 Argument();
1074 StringLengthFunction jjtn012 = new StringLengthFunction(JJTSTRINGLENGTHFUNCTION);
1075 boolean jjtc012 = true;
1076 jjtree.openNodeScope(jjtn012);
1077 jjtreeOpenNodeScope(jjtn012);
1078 try {
1079 jj_consume_token(FUNCTION_END);
1080 } finally {
1081 if (jjtc012) {
1082 jjtree.closeNodeScope(jjtn012, 1);
1083 jjtreeCloseNodeScope(jjtn012);
1084 }
1085 }
1086 break;
1087 case 41:
1088 SubstringFunction jjtn013 = new SubstringFunction(JJTSUBSTRINGFUNCTION);
1089 boolean jjtc013 = true;
1090 jjtree.openNodeScope(jjtn013);
1091 jjtreeOpenNodeScope(jjtn013);
1092 try {
1093 jj_consume_token(41);
1094 Argument();
1095 jj_consume_token(SEPARATOR);
1096 Argument();
1097 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1098 case SEPARATOR:
1099 jj_consume_token(SEPARATOR);
1100 Argument();
1101 break;
1102 default:
1103 jj_la1[18] = jj_gen;
1104 ;
1105 }
1106 jj_consume_token(FUNCTION_END);
1107 } catch (Throwable jjte013) {
1108 if (jjtc013) {
1109 jjtree.clearNodeScope(jjtn013);
1110 jjtc013 = false;
1111 } else {
1112 jjtree.popNode();
1113 }
1114 if (jjte013 instanceof RuntimeException) {
1115 {if (true) throw (RuntimeException)jjte013;}
1116 }
1117 if (jjte013 instanceof ParseException) {
1118 {if (true) throw (ParseException)jjte013;}
1119 }
1120 {if (true) throw (Error)jjte013;}
1121 } finally {
1122 if (jjtc013) {
1123 jjtree.closeNodeScope(jjtn013, jjtree.nodeArity() > 1);
1124 jjtreeCloseNodeScope(jjtn013);
1125 }
1126 }
1127 break;
1128 case 42:
1129 StartsWithFunction jjtn014 = new StartsWithFunction(JJTSTARTSWITHFUNCTION);
1130 boolean jjtc014 = true;
1131 jjtree.openNodeScope(jjtn014);
1132 jjtreeOpenNodeScope(jjtn014);
1133 try {
1134 jj_consume_token(42);
1135 Argument();
1136 jj_consume_token(SEPARATOR);
1137 Argument();
1138 jj_consume_token(FUNCTION_END);
1139 } catch (Throwable jjte014) {
1140 if (jjtc014) {
1141 jjtree.clearNodeScope(jjtn014);
1142 jjtc014 = false;
1143 } else {
1144 jjtree.popNode();
1145 }
1146 if (jjte014 instanceof RuntimeException) {
1147 {if (true) throw (RuntimeException)jjte014;}
1148 }
1149 if (jjte014 instanceof ParseException) {
1150 {if (true) throw (ParseException)jjte014;}
1151 }
1152 {if (true) throw (Error)jjte014;}
1153 } finally {
1154 if (jjtc014) {
1155 jjtree.closeNodeScope(jjtn014, 2);
1156 jjtreeCloseNodeScope(jjtn014);
1157 }
1158 }
1159 break;
1160 case 43:
1161 ContainsFunction jjtn015 = new ContainsFunction(JJTCONTAINSFUNCTION);
1162 boolean jjtc015 = true;
1163 jjtree.openNodeScope(jjtn015);
1164 jjtreeOpenNodeScope(jjtn015);
1165 try {
1166 jj_consume_token(43);
1167 Argument();
1168 jj_consume_token(SEPARATOR);
1169 Argument();
1170 jj_consume_token(FUNCTION_END);
1171 } catch (Throwable jjte015) {
1172 if (jjtc015) {
1173 jjtree.clearNodeScope(jjtn015);
1174 jjtc015 = false;
1175 } else {
1176 jjtree.popNode();
1177 }
1178 if (jjte015 instanceof RuntimeException) {
1179 {if (true) throw (RuntimeException)jjte015;}
1180 }
1181 if (jjte015 instanceof ParseException) {
1182 {if (true) throw (ParseException)jjte015;}
1183 }
1184 {if (true) throw (Error)jjte015;}
1185 } finally {
1186 if (jjtc015) {
1187 jjtree.closeNodeScope(jjtn015, 2);
1188 jjtreeCloseNodeScope(jjtn015);
1189 }
1190 }
1191 break;
1192 case 44:
1193 SubstringBeforeFunction jjtn016 = new SubstringBeforeFunction(JJTSUBSTRINGBEFOREFUNCTION);
1194 boolean jjtc016 = true;
1195 jjtree.openNodeScope(jjtn016);
1196 jjtreeOpenNodeScope(jjtn016);
1197 try {
1198 jj_consume_token(44);
1199 Argument();
1200 jj_consume_token(SEPARATOR);
1201 Argument();
1202 jj_consume_token(FUNCTION_END);
1203 } catch (Throwable jjte016) {
1204 if (jjtc016) {
1205 jjtree.clearNodeScope(jjtn016);
1206 jjtc016 = false;
1207 } else {
1208 jjtree.popNode();
1209 }
1210 if (jjte016 instanceof RuntimeException) {
1211 {if (true) throw (RuntimeException)jjte016;}
1212 }
1213 if (jjte016 instanceof ParseException) {
1214 {if (true) throw (ParseException)jjte016;}
1215 }
1216 {if (true) throw (Error)jjte016;}
1217 } finally {
1218 if (jjtc016) {
1219 jjtree.closeNodeScope(jjtn016, 2);
1220 jjtreeCloseNodeScope(jjtn016);
1221 }
1222 }
1223 break;
1224 case 45:
1225 SubstringAfterFunction jjtn017 = new SubstringAfterFunction(JJTSUBSTRINGAFTERFUNCTION);
1226 boolean jjtc017 = true;
1227 jjtree.openNodeScope(jjtn017);
1228 jjtreeOpenNodeScope(jjtn017);
1229 try {
1230 jj_consume_token(45);
1231 Argument();
1232 jj_consume_token(SEPARATOR);
1233 Argument();
1234 jj_consume_token(FUNCTION_END);
1235 } catch (Throwable jjte017) {
1236 if (jjtc017) {
1237 jjtree.clearNodeScope(jjtn017);
1238 jjtc017 = false;
1239 } else {
1240 jjtree.popNode();
1241 }
1242 if (jjte017 instanceof RuntimeException) {
1243 {if (true) throw (RuntimeException)jjte017;}
1244 }
1245 if (jjte017 instanceof ParseException) {
1246 {if (true) throw (ParseException)jjte017;}
1247 }
1248 {if (true) throw (Error)jjte017;}
1249 } finally {
1250 if (jjtc017) {
1251 jjtree.closeNodeScope(jjtn017, 2);
1252 jjtreeCloseNodeScope(jjtn017);
1253 }
1254 }
1255 break;
1256 case 46:
1257 TranslateFunction jjtn018 = new TranslateFunction(JJTTRANSLATEFUNCTION);
1258 boolean jjtc018 = true;
1259 jjtree.openNodeScope(jjtn018);
1260 jjtreeOpenNodeScope(jjtn018);
1261 try {
1262 jj_consume_token(46);
1263 Argument();
1264 jj_consume_token(SEPARATOR);
1265 Argument();
1266 jj_consume_token(SEPARATOR);
1267 Argument();
1268 jj_consume_token(FUNCTION_END);
1269 } catch (Throwable jjte018) {
1270 if (jjtc018) {
1271 jjtree.clearNodeScope(jjtn018);
1272 jjtc018 = false;
1273 } else {
1274 jjtree.popNode();
1275 }
1276 if (jjte018 instanceof RuntimeException) {
1277 {if (true) throw (RuntimeException)jjte018;}
1278 }
1279 if (jjte018 instanceof ParseException) {
1280 {if (true) throw (ParseException)jjte018;}
1281 }
1282 {if (true) throw (Error)jjte018;}
1283 } finally {
1284 if (jjtc018) {
1285 jjtree.closeNodeScope(jjtn018, 3);
1286 jjtreeCloseNodeScope(jjtn018);
1287 }
1288 }
1289 break;
1290 case 47:
1291 jj_consume_token(47);
1292 PositionFunction jjtn019 = new PositionFunction(JJTPOSITIONFUNCTION);
1293 boolean jjtc019 = true;
1294 jjtree.openNodeScope(jjtn019);
1295 jjtreeOpenNodeScope(jjtn019);
1296 try {
1297 jj_consume_token(FUNCTION_END);
1298 } finally {
1299 if (jjtc019) {
1300 jjtree.closeNodeScope(jjtn019, 0);
1301 jjtreeCloseNodeScope(jjtn019);
1302 }
1303 }
1304 break;
1305 case 48:
1306 jj_consume_token(48);
1307 CurrentFunction jjtn020 = new CurrentFunction(JJTCURRENTFUNCTION);
1308 boolean jjtc020 = true;
1309 jjtree.openNodeScope(jjtn020);
1310 jjtreeOpenNodeScope(jjtn020);
1311 try {
1312 jj_consume_token(FUNCTION_END);
1313 } finally {
1314 if (jjtc020) {
1315 jjtree.closeNodeScope(jjtn020, 0);
1316 jjtreeCloseNodeScope(jjtn020);
1317 }
1318 }
1319 break;
1320 case 49:
1321 jj_consume_token(49);
1322 LastFunction jjtn021 = new LastFunction(JJTLASTFUNCTION);
1323 boolean jjtc021 = true;
1324 jjtree.openNodeScope(jjtn021);
1325 jjtreeOpenNodeScope(jjtn021);
1326 try {
1327 jj_consume_token(FUNCTION_END);
1328 } finally {
1329 if (jjtc021) {
1330 jjtree.closeNodeScope(jjtn021, 0);
1331 jjtreeCloseNodeScope(jjtn021);
1332 }
1333 }
1334 break;
1335 case 50:
1336 jj_consume_token(50);
1337 Argument();
1338 CountFunction jjtn022 = new CountFunction(JJTCOUNTFUNCTION);
1339 boolean jjtc022 = true;
1340 jjtree.openNodeScope(jjtn022);
1341 jjtreeOpenNodeScope(jjtn022);
1342 try {
1343 jj_consume_token(FUNCTION_END);
1344 } finally {
1345 if (jjtc022) {
1346 jjtree.closeNodeScope(jjtn022, 1);
1347 jjtreeCloseNodeScope(jjtn022);
1348 }
1349 }
1350 break;
1351 case 51:
1352 jj_consume_token(51);
1353 Argument();
1354 SumFunction jjtn023 = new SumFunction(JJTSUMFUNCTION);
1355 boolean jjtc023 = true;
1356 jjtree.openNodeScope(jjtn023);
1357 jjtreeOpenNodeScope(jjtn023);
1358 try {
1359 jj_consume_token(FUNCTION_END);
1360 } finally {
1361 if (jjtc023) {
1362 jjtree.closeNodeScope(jjtn023, 1);
1363 jjtreeCloseNodeScope(jjtn023);
1364 }
1365 }
1366 break;
1367 case 52:
1368 jj_consume_token(52);
1369 NowFunction jjtn024 = new NowFunction(JJTNOWFUNCTION);
1370 boolean jjtc024 = true;
1371 jjtree.openNodeScope(jjtn024);
1372 jjtreeOpenNodeScope(jjtn024);
1373 try {
1374 jj_consume_token(FUNCTION_END);
1375 } finally {
1376 if (jjtc024) {
1377 jjtree.closeNodeScope(jjtn024, 0);
1378 jjtreeCloseNodeScope(jjtn024);
1379 }
1380 }
1381 break;
1382 case 53:
1383 DateFunction jjtn025 = new DateFunction(JJTDATEFUNCTION);
1384 boolean jjtc025 = true;
1385 jjtree.openNodeScope(jjtn025);
1386 jjtreeOpenNodeScope(jjtn025);
1387 try {
1388 jj_consume_token(53);
1389 Argument();
1390 label_11:
1391 while (true) {
1392 jj_consume_token(SEPARATOR);
1393 Argument();
1394 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1395 case SEPARATOR:
1396 ;
1397 break;
1398 default:
1399 jj_la1[19] = jj_gen;
1400 break label_11;
1401 }
1402 }
1403 jj_consume_token(FUNCTION_END);
1404 } catch (Throwable jjte025) {
1405 if (jjtc025) {
1406 jjtree.clearNodeScope(jjtn025);
1407 jjtc025 = false;
1408 } else {
1409 jjtree.popNode();
1410 }
1411 if (jjte025 instanceof RuntimeException) {
1412 {if (true) throw (RuntimeException)jjte025;}
1413 }
1414 if (jjte025 instanceof ParseException) {
1415 {if (true) throw (ParseException)jjte025;}
1416 }
1417 {if (true) throw (Error)jjte025;}
1418 } finally {
1419 if (jjtc025) {
1420 jjtree.closeNodeScope(jjtn025, jjtree.nodeArity() > 1);
1421 jjtreeCloseNodeScope(jjtn025);
1422 }
1423 }
1424 break;
1425 case 54:
1426 FormatDateFunction jjtn026 = new FormatDateFunction(JJTFORMATDATEFUNCTION);
1427 boolean jjtc026 = true;
1428 jjtree.openNodeScope(jjtn026);
1429 jjtreeOpenNodeScope(jjtn026);
1430 try {
1431 jj_consume_token(54);
1432 Argument();
1433 jj_consume_token(SEPARATOR);
1434 Argument();
1435 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1436 case SEPARATOR:
1437 jj_consume_token(SEPARATOR);
1438 Argument();
1439 break;
1440 default:
1441 jj_la1[20] = jj_gen;
1442 ;
1443 }
1444 jj_consume_token(FUNCTION_END);
1445 } catch (Throwable jjte026) {
1446 if (jjtc026) {
1447 jjtree.clearNodeScope(jjtn026);
1448 jjtc026 = false;
1449 } else {
1450 jjtree.popNode();
1451 }
1452 if (jjte026 instanceof RuntimeException) {
1453 {if (true) throw (RuntimeException)jjte026;}
1454 }
1455 if (jjte026 instanceof ParseException) {
1456 {if (true) throw (ParseException)jjte026;}
1457 }
1458 {if (true) throw (Error)jjte026;}
1459 } finally {
1460 if (jjtc026) {
1461 jjtree.closeNodeScope(jjtn026, jjtree.nodeArity() > 1);
1462 jjtreeCloseNodeScope(jjtn026);
1463 }
1464 }
1465 break;
1466 case 55:
1467 RollDateFunction jjtn027 = new RollDateFunction(JJTROLLDATEFUNCTION);
1468 boolean jjtc027 = true;
1469 jjtree.openNodeScope(jjtn027);
1470 jjtreeOpenNodeScope(jjtn027);
1471 try {
1472 jj_consume_token(55);
1473 Argument();
1474 jj_consume_token(SEPARATOR);
1475 Argument();
1476 jj_consume_token(SEPARATOR);
1477 Argument();
1478 jj_consume_token(FUNCTION_END);
1479 } catch (Throwable jjte027) {
1480 if (jjtc027) {
1481 jjtree.clearNodeScope(jjtn027);
1482 jjtc027 = false;
1483 } else {
1484 jjtree.popNode();
1485 }
1486 if (jjte027 instanceof RuntimeException) {
1487 {if (true) throw (RuntimeException)jjte027;}
1488 }
1489 if (jjte027 instanceof ParseException) {
1490 {if (true) throw (ParseException)jjte027;}
1491 }
1492 {if (true) throw (Error)jjte027;}
1493 } finally {
1494 if (jjtc027) {
1495 jjtree.closeNodeScope(jjtn027, 3);
1496 jjtreeCloseNodeScope(jjtn027);
1497 }
1498 }
1499 break;
1500 case 56:
1501 AddDateFunction jjtn028 = new AddDateFunction(JJTADDDATEFUNCTION);
1502 boolean jjtc028 = true;
1503 jjtree.openNodeScope(jjtn028);
1504 jjtreeOpenNodeScope(jjtn028);
1505 try {
1506 jj_consume_token(56);
1507 Argument();
1508 jj_consume_token(SEPARATOR);
1509 Argument();
1510 jj_consume_token(SEPARATOR);
1511 Argument();
1512 jj_consume_token(FUNCTION_END);
1513 } catch (Throwable jjte028) {
1514 if (jjtc028) {
1515 jjtree.clearNodeScope(jjtn028);
1516 jjtc028 = false;
1517 } else {
1518 jjtree.popNode();
1519 }
1520 if (jjte028 instanceof RuntimeException) {
1521 {if (true) throw (RuntimeException)jjte028;}
1522 }
1523 if (jjte028 instanceof ParseException) {
1524 {if (true) throw (ParseException)jjte028;}
1525 }
1526 {if (true) throw (Error)jjte028;}
1527 } finally {
1528 if (jjtc028) {
1529 jjtree.closeNodeScope(jjtn028, 3);
1530 jjtreeCloseNodeScope(jjtn028);
1531 }
1532 }
1533 break;
1534 case 57:
1535 TokenizeFunction jjtn029 = new TokenizeFunction(JJTTOKENIZEFUNCTION);
1536 boolean jjtc029 = true;
1537 jjtree.openNodeScope(jjtn029);
1538 jjtreeOpenNodeScope(jjtn029);
1539 try {
1540 jj_consume_token(57);
1541 Argument();
1542 jj_consume_token(SEPARATOR);
1543 Argument();
1544 jj_consume_token(FUNCTION_END);
1545 } catch (Throwable jjte029) {
1546 if (jjtc029) {
1547 jjtree.clearNodeScope(jjtn029);
1548 jjtc029 = false;
1549 } else {
1550 jjtree.popNode();
1551 }
1552 if (jjte029 instanceof RuntimeException) {
1553 {if (true) throw (RuntimeException)jjte029;}
1554 }
1555 if (jjte029 instanceof ParseException) {
1556 {if (true) throw (ParseException)jjte029;}
1557 }
1558 {if (true) throw (Error)jjte029;}
1559 } finally {
1560 if (jjtc029) {
1561 jjtree.closeNodeScope(jjtn029, 2);
1562 jjtreeCloseNodeScope(jjtn029);
1563 }
1564 }
1565 break;
1566 case IDENTIFIER:
1567 UserFunction jjtn030 = new UserFunction(JJTUSERFUNCTION);
1568 boolean jjtc030 = true;
1569 jjtree.openNodeScope(jjtn030);
1570 jjtreeOpenNodeScope(jjtn030);
1571 try {
1572 Identifier();
1573 jj_consume_token(SCOPE_LIMIT);
1574 Identifier();
1575 jj_consume_token(FUNCTION_BEGIN);
1576 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1577 case MINUS:
1578 case LIST_BEGIN:
1579 case FUNCTION_BEGIN:
1580 case 29:
1581 case 30:
1582 case 31:
1583 case 32:
1584 case 33:
1585 case 34:
1586 case 35:
1587 case 36:
1588 case 37:
1589 case 38:
1590 case 39:
1591 case 40:
1592 case 41:
1593 case 42:
1594 case 43:
1595 case 44:
1596 case 45:
1597 case 46:
1598 case 47:
1599 case 48:
1600 case 49:
1601 case 50:
1602 case 51:
1603 case 52:
1604 case 53:
1605 case 54:
1606 case 55:
1607 case 56:
1608 case 57:
1609 case SCOPE_LIMIT_NAME:
1610 case BOOLEAN_LITERAL:
1611 case STRING_LITERAL:
1612 case NUMBER_LITERAL:
1613 case IDENTIFIER:
1614 Argument();
1615 label_12:
1616 while (true) {
1617 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1618 case SEPARATOR:
1619 ;
1620 break;
1621 default:
1622 jj_la1[21] = jj_gen;
1623 break label_12;
1624 }
1625 jj_consume_token(SEPARATOR);
1626 Argument();
1627 }
1628 break;
1629 default:
1630 jj_la1[22] = jj_gen;
1631 ;
1632 }
1633 jj_consume_token(FUNCTION_END);
1634 } catch (Throwable jjte030) {
1635 if (jjtc030) {
1636 jjtree.clearNodeScope(jjtn030);
1637 jjtc030 = false;
1638 } else {
1639 jjtree.popNode();
1640 }
1641 if (jjte030 instanceof RuntimeException) {
1642 {if (true) throw (RuntimeException)jjte030;}
1643 }
1644 if (jjte030 instanceof ParseException) {
1645 {if (true) throw (ParseException)jjte030;}
1646 }
1647 {if (true) throw (Error)jjte030;}
1648 } finally {
1649 if (jjtc030) {
1650 jjtree.closeNodeScope(jjtn030, jjtree.nodeArity() > 1);
1651 jjtreeCloseNodeScope(jjtn030);
1652 }
1653 }
1654 break;
1655 default:
1656 jj_la1[23] = jj_gen;
1657 jj_consume_token(-1);
1658 throw new ParseException();
1659 }
1660 }
1661
1662
1663 final public void Argument() throws ParseException {
1664 Expr();
1665 }
1666
1667
1668 final public void ScopeLimitExpr() throws ParseException {
1669 Token t;
1670 ScopeLimitName();
1671 ScopeLimitOperator jjtn001 = new ScopeLimitOperator(JJTSCOPELIMITOPERATOR);
1672 boolean jjtc001 = true;
1673 jjtree.openNodeScope(jjtn001);
1674 jjtreeOpenNodeScope(jjtn001);
1675 try {
1676 Identifier();
1677 } catch (Throwable jjte001) {
1678 if (jjtc001) {
1679 jjtree.clearNodeScope(jjtn001);
1680 jjtc001 = false;
1681 } else {
1682 jjtree.popNode();
1683 }
1684 if (jjte001 instanceof RuntimeException) {
1685 {if (true) throw (RuntimeException)jjte001;}
1686 }
1687 if (jjte001 instanceof ParseException) {
1688 {if (true) throw (ParseException)jjte001;}
1689 }
1690 {if (true) throw (Error)jjte001;}
1691 } finally {
1692 if (jjtc001) {
1693 jjtree.closeNodeScope(jjtn001, 2);
1694 jjtreeCloseNodeScope(jjtn001);
1695 }
1696 }
1697 }
1698
1699
1700 final public void Identifier() throws ParseException {
1701
1702 Identifier jjtn000 = new Identifier(JJTIDENTIFIER);
1703 boolean jjtc000 = true;
1704 jjtree.openNodeScope(jjtn000);
1705 jjtreeOpenNodeScope(jjtn000);Token t;
1706 try {
1707 t = jj_consume_token(IDENTIFIER);
1708 jjtree.closeNodeScope(jjtn000, true);
1709 jjtc000 = false;
1710 jjtreeCloseNodeScope(jjtn000);
1711 jjtn000.val = t.image;
1712 jjtn000.image = t.image;
1713 jjtn000.beginColumn = t.beginColumn;
1714 jjtn000.endColumn = t.endColumn;
1715 jjtn000.beginLine = t.beginLine;
1716 jjtn000.endLine = t.endLine;
1717 } finally {
1718 if (jjtc000) {
1719 jjtree.closeNodeScope(jjtn000, true);
1720 jjtreeCloseNodeScope(jjtn000);
1721 }
1722 }
1723 }
1724
1725
1726 final public void ScopeLimitName() throws ParseException {
1727
1728 ScopeLimitName jjtn000 = new ScopeLimitName(JJTSCOPELIMITNAME);
1729 boolean jjtc000 = true;
1730 jjtree.openNodeScope(jjtn000);
1731 jjtreeOpenNodeScope(jjtn000);Token t;
1732 try {
1733 t = jj_consume_token(SCOPE_LIMIT_NAME);
1734 jjtree.closeNodeScope(jjtn000, true);
1735 jjtc000 = false;
1736 jjtreeCloseNodeScope(jjtn000);
1737 jjtn000.val = t.image;
1738 } finally {
1739 if (jjtc000) {
1740 jjtree.closeNodeScope(jjtn000, true);
1741 jjtreeCloseNodeScope(jjtn000);
1742 }
1743 }
1744 }
1745
1746
1747 final public void Literal() throws ParseException {
1748 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1749 case BOOLEAN_LITERAL:
1750 case STRING_LITERAL:
1751 case NUMBER_LITERAL:
1752 UnaryLiteral();
1753 break;
1754 case LIST_BEGIN:
1755 ListLiteral();
1756 break;
1757 default:
1758 jj_la1[24] = jj_gen;
1759 jj_consume_token(-1);
1760 throw new ParseException();
1761 }
1762 }
1763
1764
1765 final public void UnaryLiteral() throws ParseException {
1766 Token t;
1767 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1768 case BOOLEAN_LITERAL:
1769 BooleanLiteral jjtn001 = new BooleanLiteral(JJTBOOLEANLITERAL);
1770 boolean jjtc001 = true;
1771 jjtree.openNodeScope(jjtn001);
1772 jjtreeOpenNodeScope(jjtn001);
1773 try {
1774 t = jj_consume_token(BOOLEAN_LITERAL);
1775 jjtree.closeNodeScope(jjtn001, true);
1776 jjtc001 = false;
1777 jjtreeCloseNodeScope(jjtn001);
1778 jjtn001.val = Boolean.valueOf(t.image).booleanValue();
1779 } finally {
1780 if (jjtc001) {
1781 jjtree.closeNodeScope(jjtn001, true);
1782 jjtreeCloseNodeScope(jjtn001);
1783 }
1784 }
1785 break;
1786 case NUMBER_LITERAL:
1787 NumberLiteral jjtn002 = new NumberLiteral(JJTNUMBERLITERAL);
1788 boolean jjtc002 = true;
1789 jjtree.openNodeScope(jjtn002);
1790 jjtreeOpenNodeScope(jjtn002);
1791 try {
1792 t = jj_consume_token(NUMBER_LITERAL);
1793 jjtree.closeNodeScope(jjtn002, true);
1794 jjtc002 = false;
1795 jjtreeCloseNodeScope(jjtn002);
1796 jjtn002.val = Double.parseDouble(t.image);
1797 } finally {
1798 if (jjtc002) {
1799 jjtree.closeNodeScope(jjtn002, true);
1800 jjtreeCloseNodeScope(jjtn002);
1801 }
1802 }
1803 break;
1804 case STRING_LITERAL:
1805 StringLiteral jjtn003 = new StringLiteral(JJTSTRINGLITERAL);
1806 boolean jjtc003 = true;
1807 jjtree.openNodeScope(jjtn003);
1808 jjtreeOpenNodeScope(jjtn003);
1809 try {
1810 t = jj_consume_token(STRING_LITERAL);
1811 jjtree.closeNodeScope(jjtn003, true);
1812 jjtc003 = false;
1813 jjtreeCloseNodeScope(jjtn003);
1814 jjtn003.val = t.image.substring(1, (t.image.length() - 1));
1815 } finally {
1816 if (jjtc003) {
1817 jjtree.closeNodeScope(jjtn003, true);
1818 jjtreeCloseNodeScope(jjtn003);
1819 }
1820 }
1821 break;
1822 default:
1823 jj_la1[25] = jj_gen;
1824 jj_consume_token(-1);
1825 throw new ParseException();
1826 }
1827 }
1828
1829
1830 final public void ListLiteral() throws ParseException {
1831
1832 ListLiteral jjtn000 = new ListLiteral(JJTLISTLITERAL);
1833 boolean jjtc000 = true;
1834 jjtree.openNodeScope(jjtn000);
1835 jjtreeOpenNodeScope(jjtn000);
1836 try {
1837 jj_consume_token(LIST_BEGIN);
1838 Expr();
1839 label_13:
1840 while (true) {
1841 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1842 case SEPARATOR:
1843 ;
1844 break;
1845 default:
1846 jj_la1[26] = jj_gen;
1847 break label_13;
1848 }
1849 jj_consume_token(SEPARATOR);
1850 Expr();
1851 }
1852 ListLiteral jjtn001 = new ListLiteral(JJTLISTLITERAL);
1853 boolean jjtc001 = true;
1854 jjtree.openNodeScope(jjtn001);
1855 jjtreeOpenNodeScope(jjtn001);
1856 try {
1857 jj_consume_token(LIST_END);
1858 } finally {
1859 if (jjtc001) {
1860 jjtree.closeNodeScope(jjtn001, jjtree.nodeArity() > 1);
1861 jjtreeCloseNodeScope(jjtn001);
1862 }
1863 }
1864 } catch (Throwable jjte000) {
1865 if (jjtc000) {
1866 jjtree.clearNodeScope(jjtn000);
1867 jjtc000 = false;
1868 } else {
1869 jjtree.popNode();
1870 }
1871 if (jjte000 instanceof RuntimeException) {
1872 {if (true) throw (RuntimeException)jjte000;}
1873 }
1874 if (jjte000 instanceof ParseException) {
1875 {if (true) throw (ParseException)jjte000;}
1876 }
1877 {if (true) throw (Error)jjte000;}
1878 } finally {
1879 if (jjtc000) {
1880 jjtree.closeNodeScope(jjtn000, true);
1881 jjtreeCloseNodeScope(jjtn000);
1882 }
1883 }
1884 }
1885
1886 final private boolean jj_2_1(int xla) {
1887 jj_la = xla; jj_lastpos = jj_scanpos = token;
1888 boolean retval = !jj_3_1();
1889 jj_save(0, xla);
1890 return retval;
1891 }
1892
1893 final private boolean jj_2_2(int xla) {
1894 jj_la = xla; jj_lastpos = jj_scanpos = token;
1895 boolean retval = !jj_3_2();
1896 jj_save(1, xla);
1897 return retval;
1898 }
1899
1900 final private boolean jj_3R_21() {
1901 if (jj_scan_token(34)) return true;
1902 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
1903 if (jj_3R_46()) return true;
1904 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
1905 return false;
1906 }
1907
1908 final private boolean jj_3R_69() {
1909 if (jj_scan_token(SCOPE_LIMIT_NAME)) return true;
1910 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
1911 return false;
1912 }
1913
1914 final private boolean jj_3R_53() {
1915 if (jj_3R_54()) return true;
1916 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
1917 return false;
1918 }
1919
1920 final private boolean jj_3R_20() {
1921 if (jj_scan_token(33)) return true;
1922 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
1923 if (jj_3R_46()) return true;
1924 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
1925 return false;
1926 }
1927
1928 final private boolean jj_3R_19() {
1929 if (jj_scan_token(32)) return true;
1930 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
1931 if (jj_3R_46()) return true;
1932 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
1933 return false;
1934 }
1935
1936 final private boolean jj_3R_18() {
1937 if (jj_scan_token(31)) return true;
1938 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
1939 if (jj_3R_46()) return true;
1940 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
1941 return false;
1942 }
1943
1944 final private boolean jj_3R_17() {
1945 if (jj_scan_token(30)) return true;
1946 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
1947 if (jj_3R_46()) return true;
1948 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
1949 return false;
1950 }
1951
1952 final private boolean jj_3R_14() {
1953 Token xsp;
1954 xsp = jj_scanpos;
1955 if (jj_3R_16()) {
1956 jj_scanpos = xsp;
1957 if (jj_3R_17()) {
1958 jj_scanpos = xsp;
1959 if (jj_3R_18()) {
1960 jj_scanpos = xsp;
1961 if (jj_3R_19()) {
1962 jj_scanpos = xsp;
1963 if (jj_3R_20()) {
1964 jj_scanpos = xsp;
1965 if (jj_3R_21()) {
1966 jj_scanpos = xsp;
1967 if (jj_3R_22()) {
1968 jj_scanpos = xsp;
1969 if (jj_3R_23()) {
1970 jj_scanpos = xsp;
1971 if (jj_3R_24()) {
1972 jj_scanpos = xsp;
1973 if (jj_3R_25()) {
1974 jj_scanpos = xsp;
1975 if (jj_3R_26()) {
1976 jj_scanpos = xsp;
1977 if (jj_3R_27()) {
1978 jj_scanpos = xsp;
1979 if (jj_3R_28()) {
1980 jj_scanpos = xsp;
1981 if (jj_3R_29()) {
1982 jj_scanpos = xsp;
1983 if (jj_3R_30()) {
1984 jj_scanpos = xsp;
1985 if (jj_3R_31()) {
1986 jj_scanpos = xsp;
1987 if (jj_3R_32()) {
1988 jj_scanpos = xsp;
1989 if (jj_3R_33()) {
1990 jj_scanpos = xsp;
1991 if (jj_3R_34()) {
1992 jj_scanpos = xsp;
1993 if (jj_3R_35()) {
1994 jj_scanpos = xsp;
1995 if (jj_3R_36()) {
1996 jj_scanpos = xsp;
1997 if (jj_3R_37()) {
1998 jj_scanpos = xsp;
1999 if (jj_3R_38()) {
2000 jj_scanpos = xsp;
2001 if (jj_3R_39()) {
2002 jj_scanpos = xsp;
2003 if (jj_3R_40()) {
2004 jj_scanpos = xsp;
2005 if (jj_3R_41()) {
2006 jj_scanpos = xsp;
2007 if (jj_3R_42()) {
2008 jj_scanpos = xsp;
2009 if (jj_3R_43()) {
2010 jj_scanpos = xsp;
2011 if (jj_3R_44()) {
2012 jj_scanpos = xsp;
2013 if (jj_3R_45()) return true;
2014 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2015 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2016 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2017 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2018 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2019 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2020 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2021 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2022 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2023 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2024 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2025 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2026 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2027 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2028 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2029 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2030 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2031 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2032 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2033 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2034 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2035 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2036 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2037 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2038 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2039 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2040 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2041 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2042 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2043 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2044 return false;
2045 }
2046
2047 final private boolean jj_3R_16() {
2048 if (jj_scan_token(29)) return true;
2049 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2050 if (jj_3R_46()) return true;
2051 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2052 return false;
2053 }
2054
2055 final private boolean jj_3R_52() {
2056 if (jj_3R_53()) return true;
2057 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2058 return false;
2059 }
2060
2061 final private boolean jj_3R_15() {
2062 if (jj_scan_token(IDENTIFIER)) return true;
2063 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2064 return false;
2065 }
2066
2067 final private boolean jj_3_2() {
2068 if (jj_3R_15()) return true;
2069 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2070 return false;
2071 }
2072
2073 final private boolean jj_3R_64() {
2074 if (jj_3R_66()) return true;
2075 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2076 return false;
2077 }
2078
2079 final private boolean jj_3_1() {
2080 if (jj_3R_14()) return true;
2081 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2082 return false;
2083 }
2084
2085 final private boolean jj_3R_63() {
2086 if (jj_scan_token(FUNCTION_BEGIN)) return true;
2087 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2088 return false;
2089 }
2090
2091 final private boolean jj_3R_62() {
2092 if (jj_3R_65()) return true;
2093 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2094 return false;
2095 }
2096
2097 final private boolean jj_3R_61() {
2098 Token xsp;
2099 xsp = jj_scanpos;
2100 if (jj_3R_62()) {
2101 jj_scanpos = xsp;
2102 if (jj_3R_63()) {
2103 jj_scanpos = xsp;
2104 if (jj_3_1()) {
2105 jj_scanpos = xsp;
2106 if (jj_3R_64()) {
2107 jj_scanpos = xsp;
2108 if (jj_3_2()) return true;
2109 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2110 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2111 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2112 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2113 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2114 return false;
2115 }
2116
2117 final private boolean jj_3R_51() {
2118 if (jj_3R_52()) return true;
2119 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2120 return false;
2121 }
2122
2123 final private boolean jj_3R_66() {
2124 if (jj_3R_69()) return true;
2125 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2126 return false;
2127 }
2128
2129 final private boolean jj_3R_46() {
2130 if (jj_3R_47()) return true;
2131 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2132 return false;
2133 }
2134
2135 final private boolean jj_3R_50() {
2136 if (jj_3R_51()) return true;
2137 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2138 return false;
2139 }
2140
2141 final private boolean jj_3R_45() {
2142 if (jj_3R_15()) return true;
2143 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2144 if (jj_scan_token(SCOPE_LIMIT)) return true;
2145 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2146 return false;
2147 }
2148
2149 final private boolean jj_3R_44() {
2150 if (jj_scan_token(57)) return true;
2151 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2152 if (jj_3R_46()) return true;
2153 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2154 return false;
2155 }
2156
2157 final private boolean jj_3R_71() {
2158 if (jj_scan_token(LIST_BEGIN)) return true;
2159 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2160 return false;
2161 }
2162
2163 final private boolean jj_3R_49() {
2164 if (jj_3R_50()) return true;
2165 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2166 return false;
2167 }
2168
2169 final private boolean jj_3R_43() {
2170 if (jj_scan_token(56)) return true;
2171 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2172 if (jj_3R_46()) return true;
2173 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2174 return false;
2175 }
2176
2177 final private boolean jj_3R_60() {
2178 if (jj_3R_61()) return true;
2179 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2180 return false;
2181 }
2182
2183 final private boolean jj_3R_42() {
2184 if (jj_scan_token(55)) return true;
2185 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2186 if (jj_3R_46()) return true;
2187 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2188 return false;
2189 }
2190
2191 final private boolean jj_3R_41() {
2192 if (jj_scan_token(54)) return true;
2193 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2194 if (jj_3R_46()) return true;
2195 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2196 return false;
2197 }
2198
2199 final private boolean jj_3R_59() {
2200 if (jj_3R_60()) return true;
2201 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2202 return false;
2203 }
2204
2205 final private boolean jj_3R_40() {
2206 if (jj_scan_token(53)) return true;
2207 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2208 if (jj_3R_46()) return true;
2209 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2210 return false;
2211 }
2212
2213 final private boolean jj_3R_48() {
2214 if (jj_3R_49()) return true;
2215 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2216 return false;
2217 }
2218
2219 final private boolean jj_3R_39() {
2220 if (jj_scan_token(52)) return true;
2221 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2222 if (jj_scan_token(FUNCTION_END)) return true;
2223 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2224 return false;
2225 }
2226
2227 final private boolean jj_3R_38() {
2228 if (jj_scan_token(51)) return true;
2229 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2230 if (jj_3R_46()) return true;
2231 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2232 return false;
2233 }
2234
2235 final private boolean jj_3R_37() {
2236 if (jj_scan_token(50)) return true;
2237 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2238 if (jj_3R_46()) return true;
2239 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2240 return false;
2241 }
2242
2243 final private boolean jj_3R_74() {
2244 if (jj_scan_token(STRING_LITERAL)) return true;
2245 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2246 return false;
2247 }
2248
2249 final private boolean jj_3R_36() {
2250 if (jj_scan_token(49)) return true;
2251 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2252 if (jj_scan_token(FUNCTION_END)) return true;
2253 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2254 return false;
2255 }
2256
2257 final private boolean jj_3R_47() {
2258 if (jj_3R_48()) return true;
2259 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2260 return false;
2261 }
2262
2263 final private boolean jj_3R_35() {
2264 if (jj_scan_token(48)) return true;
2265 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2266 if (jj_scan_token(FUNCTION_END)) return true;
2267 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2268 return false;
2269 }
2270
2271 final private boolean jj_3R_58() {
2272 if (jj_3R_59()) return true;
2273 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2274 return false;
2275 }
2276
2277 final private boolean jj_3R_34() {
2278 if (jj_scan_token(47)) return true;
2279 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2280 if (jj_scan_token(FUNCTION_END)) return true;
2281 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2282 return false;
2283 }
2284
2285 final private boolean jj_3R_33() {
2286 if (jj_scan_token(46)) return true;
2287 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2288 if (jj_3R_46()) return true;
2289 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2290 return false;
2291 }
2292
2293 final private boolean jj_3R_73() {
2294 if (jj_scan_token(NUMBER_LITERAL)) return true;
2295 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2296 return false;
2297 }
2298
2299 final private boolean jj_3R_32() {
2300 if (jj_scan_token(45)) return true;
2301 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2302 if (jj_3R_46()) return true;
2303 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2304 return false;
2305 }
2306
2307 final private boolean jj_3R_57() {
2308 if (jj_3R_58()) return true;
2309 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2310 return false;
2311 }
2312
2313 final private boolean jj_3R_31() {
2314 if (jj_scan_token(44)) return true;
2315 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2316 if (jj_3R_46()) return true;
2317 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2318 return false;
2319 }
2320
2321 final private boolean jj_3R_30() {
2322 if (jj_scan_token(43)) return true;
2323 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2324 if (jj_3R_46()) return true;
2325 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2326 return false;
2327 }
2328
2329 final private boolean jj_3R_72() {
2330 if (jj_scan_token(BOOLEAN_LITERAL)) return true;
2331 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2332 return false;
2333 }
2334
2335 final private boolean jj_3R_70() {
2336 Token xsp;
2337 xsp = jj_scanpos;
2338 if (jj_3R_72()) {
2339 jj_scanpos = xsp;
2340 if (jj_3R_73()) {
2341 jj_scanpos = xsp;
2342 if (jj_3R_74()) return true;
2343 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2344 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2345 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2346 return false;
2347 }
2348
2349 final private boolean jj_3R_29() {
2350 if (jj_scan_token(42)) return true;
2351 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2352 if (jj_3R_46()) return true;
2353 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2354 return false;
2355 }
2356
2357 final private boolean jj_3R_56() {
2358 if (jj_scan_token(MINUS)) return true;
2359 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2360 return false;
2361 }
2362
2363 final private boolean jj_3R_28() {
2364 if (jj_scan_token(41)) return true;
2365 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2366 if (jj_3R_46()) return true;
2367 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2368 return false;
2369 }
2370
2371 final private boolean jj_3R_55() {
2372 if (jj_3R_57()) return true;
2373 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2374 return false;
2375 }
2376
2377 final private boolean jj_3R_54() {
2378 Token xsp;
2379 xsp = jj_scanpos;
2380 if (jj_3R_55()) {
2381 jj_scanpos = xsp;
2382 if (jj_3R_56()) return true;
2383 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2384 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2385 return false;
2386 }
2387
2388 final private boolean jj_3R_27() {
2389 if (jj_scan_token(40)) return true;
2390 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2391 if (jj_3R_46()) return true;
2392 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2393 return false;
2394 }
2395
2396 final private boolean jj_3R_26() {
2397 if (jj_scan_token(39)) return true;
2398 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2399 if (jj_3R_46()) return true;
2400 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2401 return false;
2402 }
2403
2404 final private boolean jj_3R_68() {
2405 if (jj_3R_71()) return true;
2406 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2407 return false;
2408 }
2409
2410 final private boolean jj_3R_25() {
2411 if (jj_scan_token(38)) return true;
2412 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2413 if (jj_3R_46()) return true;
2414 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2415 return false;
2416 }
2417
2418 final private boolean jj_3R_67() {
2419 if (jj_3R_70()) return true;
2420 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2421 return false;
2422 }
2423
2424 final private boolean jj_3R_65() {
2425 Token xsp;
2426 xsp = jj_scanpos;
2427 if (jj_3R_67()) {
2428 jj_scanpos = xsp;
2429 if (jj_3R_68()) return true;
2430 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2431 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2432 return false;
2433 }
2434
2435 final private boolean jj_3R_24() {
2436 if (jj_scan_token(37)) return true;
2437 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2438 if (jj_3R_46()) return true;
2439 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2440 return false;
2441 }
2442
2443 final private boolean jj_3R_23() {
2444 if (jj_scan_token(36)) return true;
2445 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2446 if (jj_3R_46()) return true;
2447 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2448 return false;
2449 }
2450
2451 final private boolean jj_3R_22() {
2452 if (jj_scan_token(35)) return true;
2453 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2454 if (jj_3R_46()) return true;
2455 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2456 return false;
2457 }
2458
2459 public ParserTokenManager token_source;
2460 ASCII_CharStream jj_input_stream;
2461 public Token token, jj_nt;
2462 private int jj_ntk;
2463 private Token jj_scanpos, jj_lastpos;
2464 private int jj_la;
2465 public boolean lookingAhead = false;
2466 private boolean jj_semLA;
2467 private int jj_gen;
2468 final private int[] jj_la1 = new int[27];
2469 final private int[] jj_la1_0 = {0x200000,0x100000,0x1800,0x1800,0x1e000,0x1e000,0x600,0x600,0x1c0,0x1c0,0xe2400400,0x40000,0x20000,0x8000000,0x2400000,0x0,0x1000000,0x1000000,0x1000000,0x1000000,0x1000000,0x1000000,0xe2400400,0xe0000000,0x400000,0x0,0x1000000,};
2470 final private int[] jj_la1_1 = {0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xdfffffff,0x0,0x0,0x0,0x58000000,0x4000000,0x0,0x0,0x0,0x0,0x0,0x0,0xdfffffff,0x83ffffff,0x58000000,0x58000000,0x0,};
2471 final private int[] jj_la1_2 = {0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,};
2472 final private JJCalls[] jj_2_rtns = new JJCalls[2];
2473 private boolean jj_rescan = false;
2474 private int jj_gc = 0;
2475
2476 public Parser(java.io.InputStream stream) {
2477 jj_input_stream = new ASCII_CharStream(stream, 1, 1);
2478 token_source = new ParserTokenManager(jj_input_stream);
2479 token = new Token();
2480 jj_ntk = -1;
2481 jj_gen = 0;
2482 for (int i = 0; i < 27; i++) jj_la1[i] = -1;
2483 for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
2484 }
2485
2486 public void ReInit(java.io.InputStream stream) {
2487 jj_input_stream.ReInit(stream, 1, 1);
2488 token_source.ReInit(jj_input_stream);
2489 token = new Token();
2490 jj_ntk = -1;
2491 jjtree.reset();
2492 jj_gen = 0;
2493 for (int i = 0; i < 27; i++) jj_la1[i] = -1;
2494 for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
2495 }
2496
2497 public Parser(java.io.Reader stream) {
2498 jj_input_stream = new ASCII_CharStream(stream, 1, 1);
2499 token_source = new ParserTokenManager(jj_input_stream);
2500 token = new Token();
2501 jj_ntk = -1;
2502 jj_gen = 0;
2503 for (int i = 0; i < 27; i++) jj_la1[i] = -1;
2504 for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
2505 }
2506
2507 public void ReInit(java.io.Reader stream) {
2508 jj_input_stream.ReInit(stream, 1, 1);
2509 token_source.ReInit(jj_input_stream);
2510 token = new Token();
2511 jj_ntk = -1;
2512 jjtree.reset();
2513 jj_gen = 0;
2514 for (int i = 0; i < 27; i++) jj_la1[i] = -1;
2515 for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
2516 }
2517
2518 public Parser(ParserTokenManager tm) {
2519 token_source = tm;
2520 token = new Token();
2521 jj_ntk = -1;
2522 jj_gen = 0;
2523 for (int i = 0; i < 27; i++) jj_la1[i] = -1;
2524 for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
2525 }
2526
2527 public void ReInit(ParserTokenManager tm) {
2528 token_source = tm;
2529 token = new Token();
2530 jj_ntk = -1;
2531 jjtree.reset();
2532 jj_gen = 0;
2533 for (int i = 0; i < 27; i++) jj_la1[i] = -1;
2534 for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
2535 }
2536
2537 final private Token jj_consume_token(int kind) throws ParseException {
2538 Token oldToken;
2539 if ((oldToken = token).next != null) token = token.next;
2540 else token = token.next = token_source.getNextToken();
2541 jj_ntk = -1;
2542 if (token.kind == kind) {
2543 jj_gen++;
2544 if (++jj_gc > 100) {
2545 jj_gc = 0;
2546 for (int i = 0; i < jj_2_rtns.length; i++) {
2547 JJCalls c = jj_2_rtns[i];
2548 while (c != null) {
2549 if (c.gen < jj_gen) c.first = null;
2550 c = c.next;
2551 }
2552 }
2553 }
2554 return token;
2555 }
2556 token = oldToken;
2557 jj_kind = kind;
2558 throw generateParseException();
2559 }
2560
2561 final private boolean jj_scan_token(int kind) {
2562 if (jj_scanpos == jj_lastpos) {
2563 jj_la--;
2564 if (jj_scanpos.next == null) {
2565 jj_lastpos = jj_scanpos = jj_scanpos.next = token_source.getNextToken();
2566 } else {
2567 jj_lastpos = jj_scanpos = jj_scanpos.next;
2568 }
2569 } else {
2570 jj_scanpos = jj_scanpos.next;
2571 }
2572 if (jj_rescan) {
2573 int i = 0; Token tok = token;
2574 while (tok != null && tok != jj_scanpos) { i++; tok = tok.next; }
2575 if (tok != null) jj_add_error_token(kind, i);
2576 }
2577 return (jj_scanpos.kind != kind);
2578 }
2579
2580 final public Token getNextToken() {
2581 if (token.next != null) token = token.next;
2582 else token = token.next = token_source.getNextToken();
2583 jj_ntk = -1;
2584 jj_gen++;
2585 return token;
2586 }
2587
2588 final public Token getToken(int index) {
2589 Token t = lookingAhead ? jj_scanpos : token;
2590 for (int i = 0; i < index; i++) {
2591 if (t.next != null) t = t.next;
2592 else t = t.next = token_source.getNextToken();
2593 }
2594 return t;
2595 }
2596
2597 final private int jj_ntk() {
2598 if ((jj_nt=token.next) == null)
2599 return (jj_ntk = (token.next=token_source.getNextToken()).kind);
2600 else
2601 return (jj_ntk = jj_nt.kind);
2602 }
2603
2604 private java.util.Vector jj_expentries = new java.util.Vector();
2605 private int[] jj_expentry;
2606 private int jj_kind = -1;
2607 private int[] jj_lasttokens = new int[100];
2608 private int jj_endpos;
2609
2610 private void jj_add_error_token(int kind, int pos) {
2611 if (pos >= 100) return;
2612 if (pos == jj_endpos + 1) {
2613 jj_lasttokens[jj_endpos++] = kind;
2614 } else if (jj_endpos != 0) {
2615 jj_expentry = new int[jj_endpos];
2616 for (int i = 0; i < jj_endpos; i++) {
2617 jj_expentry[i] = jj_lasttokens[i];
2618 }
2619 boolean exists = false;
2620 for (java.util.Enumeration enum = jj_expentries.elements(); enum.hasMoreElements();) {
2621 int[] oldentry = (int[])(enum.nextElement());
2622 if (oldentry.length == jj_expentry.length) {
2623 exists = true;
2624 for (int i = 0; i < jj_expentry.length; i++) {
2625 if (oldentry[i] != jj_expentry[i]) {
2626 exists = false;
2627 break;
2628 }
2629 }
2630 if (exists) break;
2631 }
2632 }
2633 if (!exists) jj_expentries.addElement(jj_expentry);
2634 if (pos != 0) jj_lasttokens[(jj_endpos = pos) - 1] = kind;
2635 }
2636 }
2637
2638 final public ParseException generateParseException() {
2639 jj_expentries.removeAllElements();
2640 boolean[] la1tokens = new boolean[65];
2641 for (int i = 0; i < 65; i++) {
2642 la1tokens[i] = false;
2643 }
2644 if (jj_kind >= 0) {
2645 la1tokens[jj_kind] = true;
2646 jj_kind = -1;
2647 }
2648 for (int i = 0; i < 27; i++) {
2649 if (jj_la1[i] == jj_gen) {
2650 for (int j = 0; j < 32; j++) {
2651 if ((jj_la1_0[i] & (1<<j)) != 0) {
2652 la1tokens[j] = true;
2653 }
2654 if ((jj_la1_1[i] & (1<<j)) != 0) {
2655 la1tokens[32+j] = true;
2656 }
2657 if ((jj_la1_2[i] & (1<<j)) != 0) {
2658 la1tokens[64+j] = true;
2659 }
2660 }
2661 }
2662 }
2663 for (int i = 0; i < 65; i++) {
2664 if (la1tokens[i]) {
2665 jj_expentry = new int[1];
2666 jj_expentry[0] = i;
2667 jj_expentries.addElement(jj_expentry);
2668 }
2669 }
2670 jj_endpos = 0;
2671 jj_rescan_token();
2672 jj_add_error_token(0, 0);
2673 int[][] exptokseq = new int[jj_expentries.size()][];
2674 for (int i = 0; i < jj_expentries.size(); i++) {
2675 exptokseq[i] = (int[])jj_expentries.elementAt(i);
2676 }
2677 return new ParseException(token, exptokseq, tokenImage);
2678 }
2679
2680 final public void enable_tracing() {
2681 }
2682
2683 final public void disable_tracing() {
2684 }
2685
2686 final private void jj_rescan_token() {
2687 jj_rescan = true;
2688 for (int i = 0; i < 2; i++) {
2689 JJCalls p = jj_2_rtns[i];
2690 do {
2691 if (p.gen > jj_gen) {
2692 jj_la = p.arg; jj_lastpos = jj_scanpos = p.first;
2693 switch (i) {
2694 case 0: jj_3_1(); break;
2695 case 1: jj_3_2(); break;
2696 }
2697 }
2698 p = p.next;
2699 } while (p != null);
2700 }
2701 jj_rescan = false;
2702 }
2703
2704 final private void jj_save(int index, int xla) {
2705 JJCalls p = jj_2_rtns[index];
2706 while (p.gen > jj_gen) {
2707 if (p.next == null) { p = p.next = new JJCalls(); break; }
2708 p = p.next;
2709 }
2710 p.gen = jj_gen + xla - jj_la; p.first = token; p.arg = xla;
2711 }
2712
2713 static final class JJCalls {
2714 int gen;
2715 Token first;
2716 int arg;
2717 JJCalls next;
2718 }
2719
2720}
2721 |
Popular Tags |
Java API By Example, From Geeks To Geeks.