001 /* Generated By:JavaCC: Do not edit this line. OgnlParser.java */
002 package org.apache.commons.ognl;
003
004 import java.math.*;
005
006 /**
007 * OgnlParser is a JavaCC parser class; it translates OGNL expressions into abstract
008 * syntax trees (ASTs) that can then be interpreted by the getValue and setValue methods.
009 */
010 public class OgnlParser/*@bgen(jjtree)*/implements OgnlParserTreeConstants, OgnlParserConstants {/*@bgen(jjtree)*/
011 protected JJTOgnlParserState jjtree = new JJTOgnlParserState();
012
013 /**
014 * This is the top-level construct of OGNL.
015 */
016 final public Node topLevelExpression() throws ParseException {
017 expression();
018 jj_consume_token(0);
019 {if (true) return jjtree.rootNode();}
020 throw new Error("Missing return statement in function");
021 }
022
023 // sequence (level 14)
024 final public void expression() throws ParseException {
025 assignmentExpression();
026 label_1:
027 while (true) {
028 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
029 case 1:
030 ;
031 break;
032 default:
033 jj_la1[0] = jj_gen;
034 break label_1;
035 }
036 jj_consume_token(1);
037 ASTSequence jjtn001 = new ASTSequence(JJTSEQUENCE);
038 boolean jjtc001 = true;
039 jjtree.openNodeScope(jjtn001);
040 try {
041 assignmentExpression();
042 } catch (Throwable jjte001) {
043 if (jjtc001) {
044 jjtree.clearNodeScope(jjtn001);
045 jjtc001 = false;
046 } else {
047 jjtree.popNode();
048 }
049 if (jjte001 instanceof RuntimeException) {
050 {if (true) throw (RuntimeException)jjte001;}
051 }
052 if (jjte001 instanceof ParseException) {
053 {if (true) throw (ParseException)jjte001;}
054 }
055 {if (true) throw (Error)jjte001;}
056 } finally {
057 if (jjtc001) {
058 jjtree.closeNodeScope(jjtn001, 2);
059 }
060 }
061 }
062 }
063
064 // assignment expression (level 13)
065 final public void assignmentExpression() throws ParseException {
066 conditionalTestExpression();
067 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
068 case 2:
069 jj_consume_token(2);
070 ASTAssign jjtn001 = new ASTAssign(JJTASSIGN);
071 boolean jjtc001 = true;
072 jjtree.openNodeScope(jjtn001);
073 try {
074 assignmentExpression();
075 } catch (Throwable jjte001) {
076 if (jjtc001) {
077 jjtree.clearNodeScope(jjtn001);
078 jjtc001 = false;
079 } else {
080 jjtree.popNode();
081 }
082 if (jjte001 instanceof RuntimeException) {
083 {if (true) throw (RuntimeException)jjte001;}
084 }
085 if (jjte001 instanceof ParseException) {
086 {if (true) throw (ParseException)jjte001;}
087 }
088 {if (true) throw (Error)jjte001;}
089 } finally {
090 if (jjtc001) {
091 jjtree.closeNodeScope(jjtn001, 2);
092 }
093 }
094 break;
095 default:
096 jj_la1[1] = jj_gen;
097 ;
098 }
099 }
100
101 // conditional test (level 12)
102 final public void conditionalTestExpression() throws ParseException {
103 logicalOrExpression();
104 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
105 case 3:
106 jj_consume_token(3);
107 conditionalTestExpression();
108 jj_consume_token(4);
109 ASTTest jjtn001 = new ASTTest(JJTTEST);
110 boolean jjtc001 = true;
111 jjtree.openNodeScope(jjtn001);
112 try {
113 conditionalTestExpression();
114 } catch (Throwable jjte001) {
115 if (jjtc001) {
116 jjtree.clearNodeScope(jjtn001);
117 jjtc001 = false;
118 } else {
119 jjtree.popNode();
120 }
121 if (jjte001 instanceof RuntimeException) {
122 {if (true) throw (RuntimeException)jjte001;}
123 }
124 if (jjte001 instanceof ParseException) {
125 {if (true) throw (ParseException)jjte001;}
126 }
127 {if (true) throw (Error)jjte001;}
128 } finally {
129 if (jjtc001) {
130 jjtree.closeNodeScope(jjtn001, 3);
131 }
132 }
133 break;
134 default:
135 jj_la1[2] = jj_gen;
136 ;
137 }
138 }
139
140 // logical or (||) (level 11)
141 final public void logicalOrExpression() throws ParseException {
142 logicalAndExpression();
143 label_2:
144 while (true) {
145 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
146 case 5:
147 case 6:
148 ;
149 break;
150 default:
151 jj_la1[3] = jj_gen;
152 break label_2;
153 }
154 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
155 case 5:
156 jj_consume_token(5);
157 break;
158 case 6:
159 jj_consume_token(6);
160 break;
161 default:
162 jj_la1[4] = jj_gen;
163 jj_consume_token(-1);
164 throw new ParseException();
165 }
166 ASTOr jjtn001 = new ASTOr(JJTOR);
167 boolean jjtc001 = true;
168 jjtree.openNodeScope(jjtn001);
169 try {
170 logicalAndExpression();
171 } catch (Throwable jjte001) {
172 if (jjtc001) {
173 jjtree.clearNodeScope(jjtn001);
174 jjtc001 = false;
175 } else {
176 jjtree.popNode();
177 }
178 if (jjte001 instanceof RuntimeException) {
179 {if (true) throw (RuntimeException)jjte001;}
180 }
181 if (jjte001 instanceof ParseException) {
182 {if (true) throw (ParseException)jjte001;}
183 }
184 {if (true) throw (Error)jjte001;}
185 } finally {
186 if (jjtc001) {
187 jjtree.closeNodeScope(jjtn001, 2);
188 }
189 }
190 }
191 }
192
193 // logical and (&&) (level 10)
194 final public void logicalAndExpression() throws ParseException {
195 inclusiveOrExpression();
196 label_3:
197 while (true) {
198 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
199 case 7:
200 case 8:
201 ;
202 break;
203 default:
204 jj_la1[5] = jj_gen;
205 break label_3;
206 }
207 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
208 case 7:
209 jj_consume_token(7);
210 break;
211 case 8:
212 jj_consume_token(8);
213 break;
214 default:
215 jj_la1[6] = jj_gen;
216 jj_consume_token(-1);
217 throw new ParseException();
218 }
219 ASTAnd jjtn001 = new ASTAnd(JJTAND);
220 boolean jjtc001 = true;
221 jjtree.openNodeScope(jjtn001);
222 try {
223 inclusiveOrExpression();
224 } catch (Throwable jjte001) {
225 if (jjtc001) {
226 jjtree.clearNodeScope(jjtn001);
227 jjtc001 = false;
228 } else {
229 jjtree.popNode();
230 }
231 if (jjte001 instanceof RuntimeException) {
232 {if (true) throw (RuntimeException)jjte001;}
233 }
234 if (jjte001 instanceof ParseException) {
235 {if (true) throw (ParseException)jjte001;}
236 }
237 {if (true) throw (Error)jjte001;}
238 } finally {
239 if (jjtc001) {
240 jjtree.closeNodeScope(jjtn001, 2);
241 }
242 }
243 }
244 }
245
246 // bitwise or non-short-circuiting or (|) (level 9)
247 final public void inclusiveOrExpression() throws ParseException {
248 exclusiveOrExpression();
249 label_4:
250 while (true) {
251 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
252 case 9:
253 case 10:
254 ;
255 break;
256 default:
257 jj_la1[7] = jj_gen;
258 break label_4;
259 }
260 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
261 case 9:
262 jj_consume_token(9);
263 break;
264 case 10:
265 jj_consume_token(10);
266 break;
267 default:
268 jj_la1[8] = jj_gen;
269 jj_consume_token(-1);
270 throw new ParseException();
271 }
272 ASTBitOr jjtn001 = new ASTBitOr(JJTBITOR);
273 boolean jjtc001 = true;
274 jjtree.openNodeScope(jjtn001);
275 try {
276 exclusiveOrExpression();
277 } catch (Throwable jjte001) {
278 if (jjtc001) {
279 jjtree.clearNodeScope(jjtn001);
280 jjtc001 = false;
281 } else {
282 jjtree.popNode();
283 }
284 if (jjte001 instanceof RuntimeException) {
285 {if (true) throw (RuntimeException)jjte001;}
286 }
287 if (jjte001 instanceof ParseException) {
288 {if (true) throw (ParseException)jjte001;}
289 }
290 {if (true) throw (Error)jjte001;}
291 } finally {
292 if (jjtc001) {
293 jjtree.closeNodeScope(jjtn001, 2);
294 }
295 }
296 }
297 }
298
299 // exclusive or (^) (level 8)
300 final public void exclusiveOrExpression() throws ParseException {
301 andExpression();
302 label_5:
303 while (true) {
304 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
305 case 11:
306 case 12:
307 ;
308 break;
309 default:
310 jj_la1[9] = jj_gen;
311 break label_5;
312 }
313 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
314 case 11:
315 jj_consume_token(11);
316 break;
317 case 12:
318 jj_consume_token(12);
319 break;
320 default:
321 jj_la1[10] = jj_gen;
322 jj_consume_token(-1);
323 throw new ParseException();
324 }
325 ASTXor jjtn001 = new ASTXor(JJTXOR);
326 boolean jjtc001 = true;
327 jjtree.openNodeScope(jjtn001);
328 try {
329 andExpression();
330 } catch (Throwable jjte001) {
331 if (jjtc001) {
332 jjtree.clearNodeScope(jjtn001);
333 jjtc001 = false;
334 } else {
335 jjtree.popNode();
336 }
337 if (jjte001 instanceof RuntimeException) {
338 {if (true) throw (RuntimeException)jjte001;}
339 }
340 if (jjte001 instanceof ParseException) {
341 {if (true) throw (ParseException)jjte001;}
342 }
343 {if (true) throw (Error)jjte001;}
344 } finally {
345 if (jjtc001) {
346 jjtree.closeNodeScope(jjtn001, 2);
347 }
348 }
349 }
350 }
351
352 // bitwise or non-short-circuiting and (&) (level 7)
353 final public void andExpression() throws ParseException {
354 equalityExpression();
355 label_6:
356 while (true) {
357 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
358 case 13:
359 case 14:
360 ;
361 break;
362 default:
363 jj_la1[11] = jj_gen;
364 break label_6;
365 }
366 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
367 case 13:
368 jj_consume_token(13);
369 break;
370 case 14:
371 jj_consume_token(14);
372 break;
373 default:
374 jj_la1[12] = jj_gen;
375 jj_consume_token(-1);
376 throw new ParseException();
377 }
378 ASTBitAnd jjtn001 = new ASTBitAnd(JJTBITAND);
379 boolean jjtc001 = true;
380 jjtree.openNodeScope(jjtn001);
381 try {
382 equalityExpression();
383 } catch (Throwable jjte001) {
384 if (jjtc001) {
385 jjtree.clearNodeScope(jjtn001);
386 jjtc001 = false;
387 } else {
388 jjtree.popNode();
389 }
390 if (jjte001 instanceof RuntimeException) {
391 {if (true) throw (RuntimeException)jjte001;}
392 }
393 if (jjte001 instanceof ParseException) {
394 {if (true) throw (ParseException)jjte001;}
395 }
396 {if (true) throw (Error)jjte001;}
397 } finally {
398 if (jjtc001) {
399 jjtree.closeNodeScope(jjtn001, 2);
400 }
401 }
402 }
403 }
404
405 // equality/inequality (==/!=) (level 6)
406 final public void equalityExpression() throws ParseException {
407 relationalExpression();
408 label_7:
409 while (true) {
410 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
411 case 15:
412 case 16:
413 case 17:
414 case 18:
415 ;
416 break;
417 default:
418 jj_la1[13] = jj_gen;
419 break label_7;
420 }
421 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
422 case 15:
423 case 16:
424 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
425 case 15:
426 jj_consume_token(15);
427 break;
428 case 16:
429 jj_consume_token(16);
430 break;
431 default:
432 jj_la1[14] = jj_gen;
433 jj_consume_token(-1);
434 throw new ParseException();
435 }
436 ASTEq jjtn001 = new ASTEq(JJTEQ);
437 boolean jjtc001 = true;
438 jjtree.openNodeScope(jjtn001);
439 try {
440 relationalExpression();
441 } catch (Throwable jjte001) {
442 if (jjtc001) {
443 jjtree.clearNodeScope(jjtn001);
444 jjtc001 = false;
445 } else {
446 jjtree.popNode();
447 }
448 if (jjte001 instanceof RuntimeException) {
449 {if (true) throw (RuntimeException)jjte001;}
450 }
451 if (jjte001 instanceof ParseException) {
452 {if (true) throw (ParseException)jjte001;}
453 }
454 {if (true) throw (Error)jjte001;}
455 } finally {
456 if (jjtc001) {
457 jjtree.closeNodeScope(jjtn001, 2);
458 }
459 }
460 break;
461 case 17:
462 case 18:
463 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
464 case 17:
465 jj_consume_token(17);
466 break;
467 case 18:
468 jj_consume_token(18);
469 break;
470 default:
471 jj_la1[15] = jj_gen;
472 jj_consume_token(-1);
473 throw new ParseException();
474 }
475 ASTNotEq jjtn002 = new ASTNotEq(JJTNOTEQ);
476 boolean jjtc002 = true;
477 jjtree.openNodeScope(jjtn002);
478 try {
479 relationalExpression();
480 } catch (Throwable jjte002) {
481 if (jjtc002) {
482 jjtree.clearNodeScope(jjtn002);
483 jjtc002 = false;
484 } else {
485 jjtree.popNode();
486 }
487 if (jjte002 instanceof RuntimeException) {
488 {if (true) throw (RuntimeException)jjte002;}
489 }
490 if (jjte002 instanceof ParseException) {
491 {if (true) throw (ParseException)jjte002;}
492 }
493 {if (true) throw (Error)jjte002;}
494 } finally {
495 if (jjtc002) {
496 jjtree.closeNodeScope(jjtn002, 2);
497 }
498 }
499 break;
500 default:
501 jj_la1[16] = jj_gen;
502 jj_consume_token(-1);
503 throw new ParseException();
504 }
505 }
506 }
507
508 // boolean relational expressions (level 5)
509 final public void relationalExpression() throws ParseException {
510 shiftExpression();
511 label_8:
512 while (true) {
513 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
514 case 19:
515 case 20:
516 case 21:
517 case 22:
518 case 23:
519 case 24:
520 case 25:
521 case 26:
522 case 27:
523 case 28:
524 ;
525 break;
526 default:
527 jj_la1[17] = jj_gen;
528 break label_8;
529 }
530 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
531 case 19:
532 case 20:
533 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
534 case 19:
535 jj_consume_token(19);
536 break;
537 case 20:
538 jj_consume_token(20);
539 break;
540 default:
541 jj_la1[18] = jj_gen;
542 jj_consume_token(-1);
543 throw new ParseException();
544 }
545 ASTLess jjtn001 = new ASTLess(JJTLESS);
546 boolean jjtc001 = true;
547 jjtree.openNodeScope(jjtn001);
548 try {
549 shiftExpression();
550 } catch (Throwable jjte001) {
551 if (jjtc001) {
552 jjtree.clearNodeScope(jjtn001);
553 jjtc001 = false;
554 } else {
555 jjtree.popNode();
556 }
557 if (jjte001 instanceof RuntimeException) {
558 {if (true) throw (RuntimeException)jjte001;}
559 }
560 if (jjte001 instanceof ParseException) {
561 {if (true) throw (ParseException)jjte001;}
562 }
563 {if (true) throw (Error)jjte001;}
564 } finally {
565 if (jjtc001) {
566 jjtree.closeNodeScope(jjtn001, 2);
567 }
568 }
569 break;
570 case 21:
571 case 22:
572 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
573 case 21:
574 jj_consume_token(21);
575 break;
576 case 22:
577 jj_consume_token(22);
578 break;
579 default:
580 jj_la1[19] = jj_gen;
581 jj_consume_token(-1);
582 throw new ParseException();
583 }
584 ASTGreater jjtn002 = new ASTGreater(JJTGREATER);
585 boolean jjtc002 = true;
586 jjtree.openNodeScope(jjtn002);
587 try {
588 shiftExpression();
589 } catch (Throwable jjte002) {
590 if (jjtc002) {
591 jjtree.clearNodeScope(jjtn002);
592 jjtc002 = false;
593 } else {
594 jjtree.popNode();
595 }
596 if (jjte002 instanceof RuntimeException) {
597 {if (true) throw (RuntimeException)jjte002;}
598 }
599 if (jjte002 instanceof ParseException) {
600 {if (true) throw (ParseException)jjte002;}
601 }
602 {if (true) throw (Error)jjte002;}
603 } finally {
604 if (jjtc002) {
605 jjtree.closeNodeScope(jjtn002, 2);
606 }
607 }
608 break;
609 case 23:
610 case 24:
611 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
612 case 23:
613 jj_consume_token(23);
614 break;
615 case 24:
616 jj_consume_token(24);
617 break;
618 default:
619 jj_la1[20] = jj_gen;
620 jj_consume_token(-1);
621 throw new ParseException();
622 }
623 ASTLessEq jjtn003 = new ASTLessEq(JJTLESSEQ);
624 boolean jjtc003 = true;
625 jjtree.openNodeScope(jjtn003);
626 try {
627 shiftExpression();
628 } catch (Throwable jjte003) {
629 if (jjtc003) {
630 jjtree.clearNodeScope(jjtn003);
631 jjtc003 = false;
632 } else {
633 jjtree.popNode();
634 }
635 if (jjte003 instanceof RuntimeException) {
636 {if (true) throw (RuntimeException)jjte003;}
637 }
638 if (jjte003 instanceof ParseException) {
639 {if (true) throw (ParseException)jjte003;}
640 }
641 {if (true) throw (Error)jjte003;}
642 } finally {
643 if (jjtc003) {
644 jjtree.closeNodeScope(jjtn003, 2);
645 }
646 }
647 break;
648 case 25:
649 case 26:
650 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
651 case 25:
652 jj_consume_token(25);
653 break;
654 case 26:
655 jj_consume_token(26);
656 break;
657 default:
658 jj_la1[21] = jj_gen;
659 jj_consume_token(-1);
660 throw new ParseException();
661 }
662 ASTGreaterEq jjtn004 = new ASTGreaterEq(JJTGREATEREQ);
663 boolean jjtc004 = true;
664 jjtree.openNodeScope(jjtn004);
665 try {
666 shiftExpression();
667 } catch (Throwable jjte004) {
668 if (jjtc004) {
669 jjtree.clearNodeScope(jjtn004);
670 jjtc004 = false;
671 } else {
672 jjtree.popNode();
673 }
674 if (jjte004 instanceof RuntimeException) {
675 {if (true) throw (RuntimeException)jjte004;}
676 }
677 if (jjte004 instanceof ParseException) {
678 {if (true) throw (ParseException)jjte004;}
679 }
680 {if (true) throw (Error)jjte004;}
681 } finally {
682 if (jjtc004) {
683 jjtree.closeNodeScope(jjtn004, 2);
684 }
685 }
686 break;
687 case 27:
688 jj_consume_token(27);
689 ASTIn jjtn005 = new ASTIn(JJTIN);
690 boolean jjtc005 = true;
691 jjtree.openNodeScope(jjtn005);
692 try {
693 shiftExpression();
694 } catch (Throwable jjte005) {
695 if (jjtc005) {
696 jjtree.clearNodeScope(jjtn005);
697 jjtc005 = false;
698 } else {
699 jjtree.popNode();
700 }
701 if (jjte005 instanceof RuntimeException) {
702 {if (true) throw (RuntimeException)jjte005;}
703 }
704 if (jjte005 instanceof ParseException) {
705 {if (true) throw (ParseException)jjte005;}
706 }
707 {if (true) throw (Error)jjte005;}
708 } finally {
709 if (jjtc005) {
710 jjtree.closeNodeScope(jjtn005, 2);
711 }
712 }
713 break;
714 case 28:
715 jj_consume_token(28);
716 jj_consume_token(27);
717 ASTNotIn jjtn006 = new ASTNotIn(JJTNOTIN);
718 boolean jjtc006 = true;
719 jjtree.openNodeScope(jjtn006);
720 try {
721 shiftExpression();
722 } catch (Throwable jjte006) {
723 if (jjtc006) {
724 jjtree.clearNodeScope(jjtn006);
725 jjtc006 = false;
726 } else {
727 jjtree.popNode();
728 }
729 if (jjte006 instanceof RuntimeException) {
730 {if (true) throw (RuntimeException)jjte006;}
731 }
732 if (jjte006 instanceof ParseException) {
733 {if (true) throw (ParseException)jjte006;}
734 }
735 {if (true) throw (Error)jjte006;}
736 } finally {
737 if (jjtc006) {
738 jjtree.closeNodeScope(jjtn006, 2);
739 }
740 }
741 break;
742 default:
743 jj_la1[22] = jj_gen;
744 jj_consume_token(-1);
745 throw new ParseException();
746 }
747 }
748 }
749
750 // bit shift expressions (level 4)
751 final public void shiftExpression() throws ParseException {
752 additiveExpression();
753 label_9:
754 while (true) {
755 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
756 case 29:
757 case 30:
758 case 31:
759 case 32:
760 case 33:
761 case 34:
762 ;
763 break;
764 default:
765 jj_la1[23] = jj_gen;
766 break label_9;
767 }
768 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
769 case 29:
770 case 30:
771 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
772 case 29:
773 jj_consume_token(29);
774 break;
775 case 30:
776 jj_consume_token(30);
777 break;
778 default:
779 jj_la1[24] = jj_gen;
780 jj_consume_token(-1);
781 throw new ParseException();
782 }
783 ASTShiftLeft jjtn001 = new ASTShiftLeft(JJTSHIFTLEFT);
784 boolean jjtc001 = true;
785 jjtree.openNodeScope(jjtn001);
786 try {
787 additiveExpression();
788 } catch (Throwable jjte001) {
789 if (jjtc001) {
790 jjtree.clearNodeScope(jjtn001);
791 jjtc001 = false;
792 } else {
793 jjtree.popNode();
794 }
795 if (jjte001 instanceof RuntimeException) {
796 {if (true) throw (RuntimeException)jjte001;}
797 }
798 if (jjte001 instanceof ParseException) {
799 {if (true) throw (ParseException)jjte001;}
800 }
801 {if (true) throw (Error)jjte001;}
802 } finally {
803 if (jjtc001) {
804 jjtree.closeNodeScope(jjtn001, 2);
805 }
806 }
807 break;
808 case 31:
809 case 32:
810 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
811 case 31:
812 jj_consume_token(31);
813 break;
814 case 32:
815 jj_consume_token(32);
816 break;
817 default:
818 jj_la1[25] = jj_gen;
819 jj_consume_token(-1);
820 throw new ParseException();
821 }
822 ASTShiftRight jjtn002 = new ASTShiftRight(JJTSHIFTRIGHT);
823 boolean jjtc002 = true;
824 jjtree.openNodeScope(jjtn002);
825 try {
826 additiveExpression();
827 } catch (Throwable jjte002) {
828 if (jjtc002) {
829 jjtree.clearNodeScope(jjtn002);
830 jjtc002 = false;
831 } else {
832 jjtree.popNode();
833 }
834 if (jjte002 instanceof RuntimeException) {
835 {if (true) throw (RuntimeException)jjte002;}
836 }
837 if (jjte002 instanceof ParseException) {
838 {if (true) throw (ParseException)jjte002;}
839 }
840 {if (true) throw (Error)jjte002;}
841 } finally {
842 if (jjtc002) {
843 jjtree.closeNodeScope(jjtn002, 2);
844 }
845 }
846 break;
847 case 33:
848 case 34:
849 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
850 case 33:
851 jj_consume_token(33);
852 break;
853 case 34:
854 jj_consume_token(34);
855 break;
856 default:
857 jj_la1[26] = jj_gen;
858 jj_consume_token(-1);
859 throw new ParseException();
860 }
861 ASTUnsignedShiftRight jjtn003 = new ASTUnsignedShiftRight(JJTUNSIGNEDSHIFTRIGHT);
862 boolean jjtc003 = true;
863 jjtree.openNodeScope(jjtn003);
864 try {
865 additiveExpression();
866 } catch (Throwable jjte003) {
867 if (jjtc003) {
868 jjtree.clearNodeScope(jjtn003);
869 jjtc003 = false;
870 } else {
871 jjtree.popNode();
872 }
873 if (jjte003 instanceof RuntimeException) {
874 {if (true) throw (RuntimeException)jjte003;}
875 }
876 if (jjte003 instanceof ParseException) {
877 {if (true) throw (ParseException)jjte003;}
878 }
879 {if (true) throw (Error)jjte003;}
880 } finally {
881 if (jjtc003) {
882 jjtree.closeNodeScope(jjtn003, 2);
883 }
884 }
885 break;
886 default:
887 jj_la1[27] = jj_gen;
888 jj_consume_token(-1);
889 throw new ParseException();
890 }
891 }
892 }
893
894 // binary addition/subtraction (level 3)
895 final public void additiveExpression() throws ParseException {
896 multiplicativeExpression();
897 label_10:
898 while (true) {
899 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
900 case 35:
901 case 36:
902 ;
903 break;
904 default:
905 jj_la1[28] = jj_gen;
906 break label_10;
907 }
908 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
909 case 35:
910 jj_consume_token(35);
911 ASTAdd jjtn001 = new ASTAdd(JJTADD);
912 boolean jjtc001 = true;
913 jjtree.openNodeScope(jjtn001);
914 try {
915 multiplicativeExpression();
916 } catch (Throwable jjte001) {
917 if (jjtc001) {
918 jjtree.clearNodeScope(jjtn001);
919 jjtc001 = false;
920 } else {
921 jjtree.popNode();
922 }
923 if (jjte001 instanceof RuntimeException) {
924 {if (true) throw (RuntimeException)jjte001;}
925 }
926 if (jjte001 instanceof ParseException) {
927 {if (true) throw (ParseException)jjte001;}
928 }
929 {if (true) throw (Error)jjte001;}
930 } finally {
931 if (jjtc001) {
932 jjtree.closeNodeScope(jjtn001, 2);
933 }
934 }
935 break;
936 case 36:
937 jj_consume_token(36);
938 ASTSubtract jjtn002 = new ASTSubtract(JJTSUBTRACT);
939 boolean jjtc002 = true;
940 jjtree.openNodeScope(jjtn002);
941 try {
942 multiplicativeExpression();
943 } catch (Throwable jjte002) {
944 if (jjtc002) {
945 jjtree.clearNodeScope(jjtn002);
946 jjtc002 = false;
947 } else {
948 jjtree.popNode();
949 }
950 if (jjte002 instanceof RuntimeException) {
951 {if (true) throw (RuntimeException)jjte002;}
952 }
953 if (jjte002 instanceof ParseException) {
954 {if (true) throw (ParseException)jjte002;}
955 }
956 {if (true) throw (Error)jjte002;}
957 } finally {
958 if (jjtc002) {
959 jjtree.closeNodeScope(jjtn002, 2);
960 }
961 }
962 break;
963 default:
964 jj_la1[29] = jj_gen;
965 jj_consume_token(-1);
966 throw new ParseException();
967 }
968 }
969 }
970
971 // multiplication/division/remainder (level 2)
972 final public void multiplicativeExpression() throws ParseException {
973 unaryExpression();
974 label_11:
975 while (true) {
976 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
977 case 37:
978 case 38:
979 case 39:
980 ;
981 break;
982 default:
983 jj_la1[30] = jj_gen;
984 break label_11;
985 }
986 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
987 case 37:
988 jj_consume_token(37);
989 ASTMultiply jjtn001 = new ASTMultiply(JJTMULTIPLY);
990 boolean jjtc001 = true;
991 jjtree.openNodeScope(jjtn001);
992 try {
993 unaryExpression();
994 } catch (Throwable jjte001) {
995 if (jjtc001) {
996 jjtree.clearNodeScope(jjtn001);
997 jjtc001 = false;
998 } else {
999 jjtree.popNode();
1000 }
1001 if (jjte001 instanceof RuntimeException) {
1002 {if (true) throw (RuntimeException)jjte001;}
1003 }
1004 if (jjte001 instanceof ParseException) {
1005 {if (true) throw (ParseException)jjte001;}
1006 }
1007 {if (true) throw (Error)jjte001;}
1008 } finally {
1009 if (jjtc001) {
1010 jjtree.closeNodeScope(jjtn001, 2);
1011 }
1012 }
1013 break;
1014 case 38:
1015 jj_consume_token(38);
1016 ASTDivide jjtn002 = new ASTDivide(JJTDIVIDE);
1017 boolean jjtc002 = true;
1018 jjtree.openNodeScope(jjtn002);
1019 try {
1020 unaryExpression();
1021 } catch (Throwable jjte002) {
1022 if (jjtc002) {
1023 jjtree.clearNodeScope(jjtn002);
1024 jjtc002 = false;
1025 } else {
1026 jjtree.popNode();
1027 }
1028 if (jjte002 instanceof RuntimeException) {
1029 {if (true) throw (RuntimeException)jjte002;}
1030 }
1031 if (jjte002 instanceof ParseException) {
1032 {if (true) throw (ParseException)jjte002;}
1033 }
1034 {if (true) throw (Error)jjte002;}
1035 } finally {
1036 if (jjtc002) {
1037 jjtree.closeNodeScope(jjtn002, 2);
1038 }
1039 }
1040 break;
1041 case 39:
1042 jj_consume_token(39);
1043 ASTRemainder jjtn003 = new ASTRemainder(JJTREMAINDER);
1044 boolean jjtc003 = true;
1045 jjtree.openNodeScope(jjtn003);
1046 try {
1047 unaryExpression();
1048 } catch (Throwable jjte003) {
1049 if (jjtc003) {
1050 jjtree.clearNodeScope(jjtn003);
1051 jjtc003 = false;
1052 } else {
1053 jjtree.popNode();
1054 }
1055 if (jjte003 instanceof RuntimeException) {
1056 {if (true) throw (RuntimeException)jjte003;}
1057 }
1058 if (jjte003 instanceof ParseException) {
1059 {if (true) throw (ParseException)jjte003;}
1060 }
1061 {if (true) throw (Error)jjte003;}
1062 } finally {
1063 if (jjtc003) {
1064 jjtree.closeNodeScope(jjtn003, 2);
1065 }
1066 }
1067 break;
1068 default:
1069 jj_la1[31] = jj_gen;
1070 jj_consume_token(-1);
1071 throw new ParseException();
1072 }
1073 }
1074 }
1075
1076 // unary (level 1)
1077 final public void unaryExpression() throws ParseException {
1078 StringBuilder stringBuilder;
1079 Token token;
1080 ASTInstanceof ionode;
1081 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1082 case 36:
1083 jj_consume_token(36);
1084 ASTNegate jjtn001 = new ASTNegate(JJTNEGATE);
1085 boolean jjtc001 = true;
1086 jjtree.openNodeScope(jjtn001);
1087 try {
1088 unaryExpression();
1089 } catch (Throwable jjte001) {
1090 if (jjtc001) {
1091 jjtree.clearNodeScope(jjtn001);
1092 jjtc001 = false;
1093 } else {
1094 jjtree.popNode();
1095 }
1096 if (jjte001 instanceof RuntimeException) {
1097 {if (true) throw (RuntimeException)jjte001;}
1098 }
1099 if (jjte001 instanceof ParseException) {
1100 {if (true) throw (ParseException)jjte001;}
1101 }
1102 {if (true) throw (Error)jjte001;}
1103 } finally {
1104 if (jjtc001) {
1105 jjtree.closeNodeScope(jjtn001, 1);
1106 }
1107 }
1108 break;
1109 case 35:
1110 jj_consume_token(35);
1111 unaryExpression();
1112 break;
1113 case 40:
1114 jj_consume_token(40);
1115 ASTBitNegate jjtn002 = new ASTBitNegate(JJTBITNEGATE);
1116 boolean jjtc002 = true;
1117 jjtree.openNodeScope(jjtn002);
1118 try {
1119 unaryExpression();
1120 } catch (Throwable jjte002) {
1121 if (jjtc002) {
1122 jjtree.clearNodeScope(jjtn002);
1123 jjtc002 = false;
1124 } else {
1125 jjtree.popNode();
1126 }
1127 if (jjte002 instanceof RuntimeException) {
1128 {if (true) throw (RuntimeException)jjte002;}
1129 }
1130 if (jjte002 instanceof ParseException) {
1131 {if (true) throw (ParseException)jjte002;}
1132 }
1133 {if (true) throw (Error)jjte002;}
1134 } finally {
1135 if (jjtc002) {
1136 jjtree.closeNodeScope(jjtn002, 1);
1137 }
1138 }
1139 break;
1140 case 28:
1141 case 41:
1142 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1143 case 41:
1144 jj_consume_token(41);
1145 break;
1146 case 28:
1147 jj_consume_token(28);
1148 break;
1149 default:
1150 jj_la1[32] = jj_gen;
1151 jj_consume_token(-1);
1152 throw new ParseException();
1153 }
1154 ASTNot jjtn003 = new ASTNot(JJTNOT);
1155 boolean jjtc003 = true;
1156 jjtree.openNodeScope(jjtn003);
1157 try {
1158 unaryExpression();
1159 } catch (Throwable jjte003) {
1160 if (jjtc003) {
1161 jjtree.clearNodeScope(jjtn003);
1162 jjtc003 = false;
1163 } else {
1164 jjtree.popNode();
1165 }
1166 if (jjte003 instanceof RuntimeException) {
1167 {if (true) throw (RuntimeException)jjte003;}
1168 }
1169 if (jjte003 instanceof ParseException) {
1170 {if (true) throw (ParseException)jjte003;}
1171 }
1172 {if (true) throw (Error)jjte003;}
1173 } finally {
1174 if (jjtc003) {
1175 jjtree.closeNodeScope(jjtn003, 1);
1176 }
1177 }
1178 break;
1179 case 4:
1180 case 44:
1181 case 46:
1182 case 47:
1183 case 48:
1184 case 49:
1185 case 50:
1186 case 51:
1187 case 52:
1188 case 54:
1189 case 56:
1190 case 57:
1191 case IDENT:
1192 case DYNAMIC_SUBSCRIPT:
1193 case CHAR_LITERAL:
1194 case BACK_CHAR_LITERAL:
1195 case STRING_LITERAL:
1196 case INT_LITERAL:
1197 case FLT_LITERAL:
1198 navigationChain();
1199 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1200 case 42:
1201 jj_consume_token(42);
1202 token = jj_consume_token(IDENT);
1203 ASTInstanceof jjtn004 = new ASTInstanceof(JJTINSTANCEOF);
1204 boolean jjtc004 = true;
1205 jjtree.openNodeScope(jjtn004);
1206 try {
1207 jjtree.closeNodeScope(jjtn004, 1);
1208 jjtc004 = false;
1209 stringBuilder = new StringBuilder(token.image); ionode = jjtn004;
1210 } finally {
1211 if (jjtc004) {
1212 jjtree.closeNodeScope(jjtn004, 1);
1213 }
1214 }
1215 label_12:
1216 while (true) {
1217 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1218 case 43:
1219 ;
1220 break;
1221 default:
1222 jj_la1[33] = jj_gen;
1223 break label_12;
1224 }
1225 jj_consume_token(43);
1226 token = jj_consume_token(IDENT);
1227 stringBuilder.append('.').append( token.image );
1228 }
1229 ionode.setTargetType( stringBuilder.toString() );
1230 break;
1231 default:
1232 jj_la1[34] = jj_gen;
1233 ;
1234 }
1235 break;
1236 default:
1237 jj_la1[35] = jj_gen;
1238 jj_consume_token(-1);
1239 throw new ParseException();
1240 }
1241 }
1242
1243 // navigation chain: property references, method calls, projections, selections, etc.
1244 final public void navigationChain() throws ParseException {
1245 primaryExpression();
1246 label_13:
1247 while (true) {
1248 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1249 case 43:
1250 case 44:
1251 case 52:
1252 case DYNAMIC_SUBSCRIPT:
1253 ;
1254 break;
1255 default:
1256 jj_la1[36] = jj_gen;
1257 break label_13;
1258 }
1259 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1260 case 43:
1261 jj_consume_token(43);
1262 ASTChain jjtn001 = new ASTChain(JJTCHAIN);
1263 boolean jjtc001 = true;
1264 jjtree.openNodeScope(jjtn001);
1265 try {
1266 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1267 case IDENT:
1268 if (jj_2_1(2)) {
1269 methodCall();
1270 } else {
1271 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1272 case IDENT:
1273 propertyName();
1274 break;
1275 default:
1276 jj_la1[37] = jj_gen;
1277 jj_consume_token(-1);
1278 throw new ParseException();
1279 }
1280 }
1281 break;
1282 case 54:
1283 if (jj_2_2(2)) {
1284 projection();
1285 } else {
1286 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1287 case 54:
1288 selection();
1289 break;
1290 default:
1291 jj_la1[38] = jj_gen;
1292 jj_consume_token(-1);
1293 throw new ParseException();
1294 }
1295 }
1296 break;
1297 case 44:
1298 jj_consume_token(44);
1299 expression();
1300 jj_consume_token(45);
1301 break;
1302 default:
1303 jj_la1[39] = jj_gen;
1304 jj_consume_token(-1);
1305 throw new ParseException();
1306 }
1307 } catch (Throwable jjte001) {
1308 if (jjtc001) {
1309 jjtree.clearNodeScope(jjtn001);
1310 jjtc001 = false;
1311 } else {
1312 jjtree.popNode();
1313 }
1314 if (jjte001 instanceof RuntimeException) {
1315 {if (true) throw (RuntimeException)jjte001;}
1316 }
1317 if (jjte001 instanceof ParseException) {
1318 {if (true) throw (ParseException)jjte001;}
1319 }
1320 {if (true) throw (Error)jjte001;}
1321 } finally {
1322 if (jjtc001) {
1323 jjtree.closeNodeScope(jjtn001, 2);
1324 }
1325 }
1326 break;
1327 case 52:
1328 case DYNAMIC_SUBSCRIPT:
1329 ASTChain jjtn002 = new ASTChain(JJTCHAIN);
1330 boolean jjtc002 = true;
1331 jjtree.openNodeScope(jjtn002);
1332 try {
1333 index();
1334 } catch (Throwable jjte002) {
1335 if (jjtc002) {
1336 jjtree.clearNodeScope(jjtn002);
1337 jjtc002 = false;
1338 } else {
1339 jjtree.popNode();
1340 }
1341 if (jjte002 instanceof RuntimeException) {
1342 {if (true) throw (RuntimeException)jjte002;}
1343 }
1344 if (jjte002 instanceof ParseException) {
1345 {if (true) throw (ParseException)jjte002;}
1346 }
1347 {if (true) throw (Error)jjte002;}
1348 } finally {
1349 if (jjtc002) {
1350 jjtree.closeNodeScope(jjtn002, 2);
1351 }
1352 }
1353 break;
1354 case 44:
1355 jj_consume_token(44);
1356 expression();
1357 ASTEval jjtn003 = new ASTEval(JJTEVAL);
1358 boolean jjtc003 = true;
1359 jjtree.openNodeScope(jjtn003);
1360 try {
1361 jj_consume_token(45);
1362 } finally {
1363 if (jjtc003) {
1364 jjtree.closeNodeScope(jjtn003, 2);
1365 }
1366 }
1367 break;
1368 default:
1369 jj_la1[40] = jj_gen;
1370 jj_consume_token(-1);
1371 throw new ParseException();
1372 }
1373 }
1374 }
1375
1376 final public void primaryExpression() throws ParseException {
1377 Token token;
1378 String className = null;
1379 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1380 case CHAR_LITERAL:
1381 case BACK_CHAR_LITERAL:
1382 case STRING_LITERAL:
1383 case INT_LITERAL:
1384 case FLT_LITERAL:
1385 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1386 case CHAR_LITERAL:
1387 jj_consume_token(CHAR_LITERAL);
1388 break;
1389 case BACK_CHAR_LITERAL:
1390 jj_consume_token(BACK_CHAR_LITERAL);
1391 break;
1392 case STRING_LITERAL:
1393 jj_consume_token(STRING_LITERAL);
1394 break;
1395 case INT_LITERAL:
1396 jj_consume_token(INT_LITERAL);
1397 break;
1398 case FLT_LITERAL:
1399 jj_consume_token(FLT_LITERAL);
1400 break;
1401 default:
1402 jj_la1[41] = jj_gen;
1403 jj_consume_token(-1);
1404 throw new ParseException();
1405 }
1406 ASTConst jjtn001 = new ASTConst(JJTCONST);
1407 boolean jjtc001 = true;
1408 jjtree.openNodeScope(jjtn001);
1409 try {
1410 jjtree.closeNodeScope(jjtn001, 0);
1411 jjtc001 = false;
1412 jjtn001.setValue( token_source.literalValue );
1413 } finally {
1414 if (jjtc001) {
1415 jjtree.closeNodeScope(jjtn001, 0);
1416 }
1417 }
1418 break;
1419 case 46:
1420 jj_consume_token(46);
1421 ASTConst jjtn002 = new ASTConst(JJTCONST);
1422 boolean jjtc002 = true;
1423 jjtree.openNodeScope(jjtn002);
1424 try {
1425 jjtree.closeNodeScope(jjtn002, 0);
1426 jjtc002 = false;
1427 jjtn002.setValue( Boolean.TRUE );
1428 } finally {
1429 if (jjtc002) {
1430 jjtree.closeNodeScope(jjtn002, 0);
1431 }
1432 }
1433 break;
1434 case 47:
1435 jj_consume_token(47);
1436 ASTConst jjtn003 = new ASTConst(JJTCONST);
1437 boolean jjtc003 = true;
1438 jjtree.openNodeScope(jjtn003);
1439 try {
1440 jjtree.closeNodeScope(jjtn003, 0);
1441 jjtc003 = false;
1442 jjtn003.setValue( Boolean.FALSE );
1443 } finally {
1444 if (jjtc003) {
1445 jjtree.closeNodeScope(jjtn003, 0);
1446 }
1447 }
1448 break;
1449 case 48:
1450 ASTConst jjtn004 = new ASTConst(JJTCONST);
1451 boolean jjtc004 = true;
1452 jjtree.openNodeScope(jjtn004);
1453 try {
1454 jj_consume_token(48);
1455 } finally {
1456 if (jjtc004) {
1457 jjtree.closeNodeScope(jjtn004, 0);
1458 }
1459 }
1460 break;
1461 default:
1462 jj_la1[48] = jj_gen;
1463 if (jj_2_4(2)) {
1464 jj_consume_token(49);
1465 ASTThisVarRef jjtn005 = new ASTThisVarRef(JJTTHISVARREF);
1466 boolean jjtc005 = true;
1467 jjtree.openNodeScope(jjtn005);
1468 try {
1469 jjtree.closeNodeScope(jjtn005, 0);
1470 jjtc005 = false;
1471 jjtn005.setName( "this" );
1472 } finally {
1473 if (jjtc005) {
1474 jjtree.closeNodeScope(jjtn005, 0);
1475 }
1476 }
1477 } else if (jj_2_5(2)) {
1478 jj_consume_token(50);
1479 ASTRootVarRef jjtn006 = new ASTRootVarRef(JJTROOTVARREF);
1480 boolean jjtc006 = true;
1481 jjtree.openNodeScope(jjtn006);
1482 try {
1483 jjtree.closeNodeScope(jjtn006, 0);
1484 jjtc006 = false;
1485 jjtn006.setName( "root" );
1486 } finally {
1487 if (jjtc006) {
1488 jjtree.closeNodeScope(jjtn006, 0);
1489 }
1490 }
1491 } else if (jj_2_6(2)) {
1492 jj_consume_token(51);
1493 token = jj_consume_token(IDENT);
1494 ASTVarRef jjtn007 = new ASTVarRef(JJTVARREF);
1495 boolean jjtc007 = true;
1496 jjtree.openNodeScope(jjtn007);
1497 try {
1498 jjtree.closeNodeScope(jjtn007, 0);
1499 jjtc007 = false;
1500 jjtn007.setName( token.image );
1501 } finally {
1502 if (jjtc007) {
1503 jjtree.closeNodeScope(jjtn007, 0);
1504 }
1505 }
1506 } else if (jj_2_7(2)) {
1507 jj_consume_token(4);
1508 jj_consume_token(52);
1509 expression();
1510 jj_consume_token(53);
1511 ASTConst jjtn008 = new ASTConst(JJTCONST);
1512 boolean jjtc008 = true;
1513 jjtree.openNodeScope(jjtn008);
1514 try {
1515 jjtree.closeNodeScope(jjtn008, 1);
1516 jjtc008 = false;
1517 jjtn008.setValue( jjtn008.jjtGetChild(0) );
1518 } finally {
1519 if (jjtc008) {
1520 jjtree.closeNodeScope(jjtn008, 1);
1521 }
1522 }
1523 } else {
1524 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1525 case 56:
1526 staticReference();
1527 break;
1528 default:
1529 jj_la1[49] = jj_gen;
1530 if (jj_2_8(2)) {
1531 constructorCall();
1532 } else {
1533 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1534 case IDENT:
1535 if (jj_2_3(2)) {
1536 methodCall();
1537 } else {
1538 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1539 case IDENT:
1540 propertyName();
1541 break;
1542 default:
1543 jj_la1[42] = jj_gen;
1544 jj_consume_token(-1);
1545 throw new ParseException();
1546 }
1547 }
1548 break;
1549 case 52:
1550 case DYNAMIC_SUBSCRIPT:
1551 index();
1552 break;
1553 case 44:
1554 jj_consume_token(44);
1555 expression();
1556 jj_consume_token(45);
1557 break;
1558 case 54:
1559 jj_consume_token(54);
1560 ASTList jjtn009 = new ASTList(JJTLIST);
1561 boolean jjtc009 = true;
1562 jjtree.openNodeScope(jjtn009);
1563 try {
1564 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1565 case 4:
1566 case 28:
1567 case 35:
1568 case 36:
1569 case 40:
1570 case 41:
1571 case 44:
1572 case 46:
1573 case 47:
1574 case 48:
1575 case 49:
1576 case 50:
1577 case 51:
1578 case 52:
1579 case 54:
1580 case 56:
1581 case 57:
1582 case IDENT:
1583 case DYNAMIC_SUBSCRIPT:
1584 case CHAR_LITERAL:
1585 case BACK_CHAR_LITERAL:
1586 case STRING_LITERAL:
1587 case INT_LITERAL:
1588 case FLT_LITERAL:
1589 assignmentExpression();
1590 label_14:
1591 while (true) {
1592 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1593 case 1:
1594 ;
1595 break;
1596 default:
1597 jj_la1[43] = jj_gen;
1598 break label_14;
1599 }
1600 jj_consume_token(1);
1601 assignmentExpression();
1602 }
1603 break;
1604 default:
1605 jj_la1[44] = jj_gen;
1606 ;
1607 }
1608 } catch (Throwable jjte009) {
1609 if (jjtc009) {
1610 jjtree.clearNodeScope(jjtn009);
1611 jjtc009 = false;
1612 } else {
1613 jjtree.popNode();
1614 }
1615 if (jjte009 instanceof RuntimeException) {
1616 {if (true) throw (RuntimeException)jjte009;}
1617 }
1618 if (jjte009 instanceof ParseException) {
1619 {if (true) throw (ParseException)jjte009;}
1620 }
1621 {if (true) throw (Error)jjte009;}
1622 } finally {
1623 if (jjtc009) {
1624 jjtree.closeNodeScope(jjtn009, true);
1625 }
1626 }
1627 jj_consume_token(55);
1628 break;
1629 default:
1630 jj_la1[50] = jj_gen;
1631 if (jj_2_9(2)) {
1632 ASTMap jjtn010 = new ASTMap(JJTMAP);
1633 boolean jjtc010 = true;
1634 jjtree.openNodeScope(jjtn010);
1635 try {
1636 jj_consume_token(51);
1637 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1638 case 56:
1639 className = classReference();
1640 break;
1641 default:
1642 jj_la1[45] = jj_gen;
1643 ;
1644 }
1645 jj_consume_token(54);
1646 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1647 case 4:
1648 case 28:
1649 case 35:
1650 case 36:
1651 case 40:
1652 case 41:
1653 case 44:
1654 case 46:
1655 case 47:
1656 case 48:
1657 case 49:
1658 case 50:
1659 case 51:
1660 case 52:
1661 case 54:
1662 case 56:
1663 case 57:
1664 case IDENT:
1665 case DYNAMIC_SUBSCRIPT:
1666 case CHAR_LITERAL:
1667 case BACK_CHAR_LITERAL:
1668 case STRING_LITERAL:
1669 case INT_LITERAL:
1670 case FLT_LITERAL:
1671 keyValueExpression();
1672 label_15:
1673 while (true) {
1674 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1675 case 1:
1676 ;
1677 break;
1678 default:
1679 jj_la1[46] = jj_gen;
1680 break label_15;
1681 }
1682 jj_consume_token(1);
1683 keyValueExpression();
1684 }
1685 break;
1686 default:
1687 jj_la1[47] = jj_gen;
1688 ;
1689 }
1690 jjtn010.setClassName(className);
1691 jj_consume_token(55);
1692 } catch (Throwable jjte010) {
1693 if (jjtc010) {
1694 jjtree.clearNodeScope(jjtn010);
1695 jjtc010 = false;
1696 } else {
1697 jjtree.popNode();
1698 }
1699 if (jjte010 instanceof RuntimeException) {
1700 {if (true) throw (RuntimeException)jjte010;}
1701 }
1702 if (jjte010 instanceof ParseException) {
1703 {if (true) throw (ParseException)jjte010;}
1704 }
1705 {if (true) throw (Error)jjte010;}
1706 } finally {
1707 if (jjtc010) {
1708 jjtree.closeNodeScope(jjtn010, true);
1709 }
1710 }
1711 } else {
1712 jj_consume_token(-1);
1713 throw new ParseException();
1714 }
1715 }
1716 }
1717 }
1718 }
1719 }
1720 }
1721
1722 final public void keyValueExpression() throws ParseException {
1723 ASTKeyValue jjtn001 = new ASTKeyValue(JJTKEYVALUE);
1724 boolean jjtc001 = true;
1725 jjtree.openNodeScope(jjtn001);
1726 try {
1727 assignmentExpression();
1728 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1729 case 4:
1730 jj_consume_token(4);
1731 assignmentExpression();
1732 break;
1733 default:
1734 jj_la1[51] = jj_gen;
1735 ;
1736 }
1737 } catch (Throwable jjte001) {
1738 if (jjtc001) {
1739 jjtree.clearNodeScope(jjtn001);
1740 jjtc001 = false;
1741 } else {
1742 jjtree.popNode();
1743 }
1744 if (jjte001 instanceof RuntimeException) {
1745 {if (true) throw (RuntimeException)jjte001;}
1746 }
1747 if (jjte001 instanceof ParseException) {
1748 {if (true) throw (ParseException)jjte001;}
1749 }
1750 {if (true) throw (Error)jjte001;}
1751 } finally {
1752 if (jjtc001) {
1753 jjtree.closeNodeScope(jjtn001, true);
1754 }
1755 }
1756 }
1757
1758 final public void staticReference() throws ParseException {
1759 String className = "java.lang.Math";
1760 Token token;
1761 className = classReference();
1762 if (jj_2_10(2)) {
1763 staticMethodCall(className);
1764 } else {
1765 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1766 case IDENT:
1767 token = jj_consume_token(IDENT);
1768 ASTStaticField jjtn001 = new ASTStaticField(JJTSTATICFIELD);
1769 boolean jjtc001 = true;
1770 jjtree.openNodeScope(jjtn001);
1771 try {
1772 jjtree.closeNodeScope(jjtn001, 0);
1773 jjtc001 = false;
1774 jjtn001.init( className, token.image );
1775 } finally {
1776 if (jjtc001) {
1777 jjtree.closeNodeScope(jjtn001, 0);
1778 }
1779 }
1780 break;
1781 default:
1782 jj_la1[52] = jj_gen;
1783 jj_consume_token(-1);
1784 throw new ParseException();
1785 }
1786 }
1787 }
1788
1789 final public String classReference() throws ParseException {
1790 String result = "java.lang.Math";
1791 jj_consume_token(56);
1792 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1793 case IDENT:
1794 result = className();
1795 break;
1796 default:
1797 jj_la1[53] = jj_gen;
1798 ;
1799 }
1800 jj_consume_token(56);
1801 {if (true) return result;}
1802 throw new Error("Missing return statement in function");
1803 }
1804
1805 final public String className() throws ParseException {
1806 Token token;
1807 StringBuilder result;
1808 token = jj_consume_token(IDENT);
1809 result = new StringBuilder( token.image );
1810 label_16:
1811 while (true) {
1812 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1813 case 43:
1814 ;
1815 break;
1816 default:
1817 jj_la1[54] = jj_gen;
1818 break label_16;
1819 }
1820 jj_consume_token(43);
1821 token = jj_consume_token(IDENT);
1822 result.append('.').append( token.image );
1823 }
1824 {if (true) return result.toString();}
1825 throw new Error("Missing return statement in function");
1826 }
1827
1828 final public void constructorCall() throws ParseException {
1829 /*@bgen(jjtree) Ctor */
1830 ASTCtor jjtn000 = new ASTCtor(JJTCTOR);
1831 boolean jjtc000 = true;
1832 jjtree.openNodeScope(jjtn000);String className;
1833 Token token;
1834 StringBuilder stringBuilder;
1835 try {
1836 jj_consume_token(57);
1837 className = className();
1838 if (jj_2_11(2)) {
1839 jj_consume_token(44);
1840 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1841 case 4:
1842 case 28:
1843 case 35:
1844 case 36:
1845 case 40:
1846 case 41:
1847 case 44:
1848 case 46:
1849 case 47:
1850 case 48:
1851 case 49:
1852 case 50:
1853 case 51:
1854 case 52:
1855 case 54:
1856 case 56:
1857 case 57:
1858 case IDENT:
1859 case DYNAMIC_SUBSCRIPT:
1860 case CHAR_LITERAL:
1861 case BACK_CHAR_LITERAL:
1862 case STRING_LITERAL:
1863 case INT_LITERAL:
1864 case FLT_LITERAL:
1865 assignmentExpression();
1866 label_17:
1867 while (true) {
1868 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1869 case 1:
1870 ;
1871 break;
1872 default:
1873 jj_la1[55] = jj_gen;
1874 break label_17;
1875 }
1876 jj_consume_token(1);
1877 assignmentExpression();
1878 }
1879 break;
1880 default:
1881 jj_la1[56] = jj_gen;
1882 ;
1883 }
1884 jj_consume_token(45);
1885 jjtree.closeNodeScope(jjtn000, true);
1886 jjtc000 = false;
1887 jjtn000.setClassName(className);
1888 } else if (jj_2_12(2)) {
1889 jj_consume_token(52);
1890 jj_consume_token(53);
1891 jj_consume_token(54);
1892 ASTList jjtn001 = new ASTList(JJTLIST);
1893 boolean jjtc001 = true;
1894 jjtree.openNodeScope(jjtn001);
1895 try {
1896 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1897 case 4:
1898 case 28:
1899 case 35:
1900 case 36:
1901 case 40:
1902 case 41:
1903 case 44:
1904 case 46:
1905 case 47:
1906 case 48:
1907 case 49:
1908 case 50:
1909 case 51:
1910 case 52:
1911 case 54:
1912 case 56:
1913 case 57:
1914 case IDENT:
1915 case DYNAMIC_SUBSCRIPT:
1916 case CHAR_LITERAL:
1917 case BACK_CHAR_LITERAL:
1918 case STRING_LITERAL:
1919 case INT_LITERAL:
1920 case FLT_LITERAL:
1921 assignmentExpression();
1922 label_18:
1923 while (true) {
1924 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1925 case 1:
1926 ;
1927 break;
1928 default:
1929 jj_la1[57] = jj_gen;
1930 break label_18;
1931 }
1932 jj_consume_token(1);
1933 assignmentExpression();
1934 }
1935 break;
1936 default:
1937 jj_la1[58] = jj_gen;
1938 ;
1939 }
1940 } catch (Throwable jjte001) {
1941 if (jjtc001) {
1942 jjtree.clearNodeScope(jjtn001);
1943 jjtc001 = false;
1944 } else {
1945 jjtree.popNode();
1946 }
1947 if (jjte001 instanceof RuntimeException) {
1948 {if (true) throw (RuntimeException)jjte001;}
1949 }
1950 if (jjte001 instanceof ParseException) {
1951 {if (true) throw (ParseException)jjte001;}
1952 }
1953 {if (true) throw (Error)jjte001;}
1954 } finally {
1955 if (jjtc001) {
1956 jjtree.closeNodeScope(jjtn001, true);
1957 }
1958 }
1959 jj_consume_token(55);
1960 jjtree.closeNodeScope(jjtn000, true);
1961 jjtc000 = false;
1962 jjtn000.setClassName(className);
1963 jjtn000.setArray(true);
1964 } else if (jj_2_13(2)) {
1965 jj_consume_token(52);
1966 assignmentExpression();
1967 jj_consume_token(53);
1968 jjtree.closeNodeScope(jjtn000, true);
1969 jjtc000 = false;
1970 jjtn000.setClassName(className);
1971 jjtn000.setArray(true);
1972 } else {
1973 jj_consume_token(-1);
1974 throw new ParseException();
1975 }
1976 } catch (Throwable jjte000) {
1977 if (jjtc000) {
1978 jjtree.clearNodeScope(jjtn000);
1979 jjtc000 = false;
1980 } else {
1981 jjtree.popNode();
1982 }
1983 if (jjte000 instanceof RuntimeException) {
1984 {if (true) throw (RuntimeException)jjte000;}
1985 }
1986 if (jjte000 instanceof ParseException) {
1987 {if (true) throw (ParseException)jjte000;}
1988 }
1989 {if (true) throw (Error)jjte000;}
1990 } finally {
1991 if (jjtc000) {
1992 jjtree.closeNodeScope(jjtn000, true);
1993 }
1994 }
1995 }
1996
1997 final public void propertyName() throws ParseException {
1998 /*@bgen(jjtree) Property */
1999 ASTProperty jjtn000 = new ASTProperty(JJTPROPERTY);
2000 boolean jjtc000 = true;
2001 jjtree.openNodeScope(jjtn000);Token token;
2002 try {
2003 token = jj_consume_token(IDENT);
2004 ASTConst jjtn001 = new ASTConst(JJTCONST);
2005 boolean jjtc001 = true;
2006 jjtree.openNodeScope(jjtn001);
2007 try {
2008 jjtree.closeNodeScope(jjtn001, true);
2009 jjtc001 = false;
2010 jjtn001.setValue( token.image );
2011 } finally {
2012 if (jjtc001) {
2013 jjtree.closeNodeScope(jjtn001, true);
2014 }
2015 }
2016 } finally {
2017 if (jjtc000) {
2018 jjtree.closeNodeScope(jjtn000, true);
2019 }
2020 }
2021 }
2022
2023 final public void staticMethodCall(String className) throws ParseException {
2024 /*@bgen(jjtree) StaticMethod */
2025 ASTStaticMethod jjtn000 = new ASTStaticMethod(JJTSTATICMETHOD);
2026 boolean jjtc000 = true;
2027 jjtree.openNodeScope(jjtn000);Token token;
2028 try {
2029 token = jj_consume_token(IDENT);
2030 jj_consume_token(44);
2031 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2032 case 4:
2033 case 28:
2034 case 35:
2035 case 36:
2036 case 40:
2037 case 41:
2038 case 44:
2039 case 46:
2040 case 47:
2041 case 48:
2042 case 49:
2043 case 50:
2044 case 51:
2045 case 52:
2046 case 54:
2047 case 56:
2048 case 57:
2049 case IDENT:
2050 case DYNAMIC_SUBSCRIPT:
2051 case CHAR_LITERAL:
2052 case BACK_CHAR_LITERAL:
2053 case STRING_LITERAL:
2054 case INT_LITERAL:
2055 case FLT_LITERAL:
2056 assignmentExpression();
2057 label_19:
2058 while (true) {
2059 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2060 case 1:
2061 ;
2062 break;
2063 default:
2064 jj_la1[59] = jj_gen;
2065 break label_19;
2066 }
2067 jj_consume_token(1);
2068 assignmentExpression();
2069 }
2070 break;
2071 default:
2072 jj_la1[60] = jj_gen;
2073 ;
2074 }
2075 jj_consume_token(45);
2076 jjtree.closeNodeScope(jjtn000, true);
2077 jjtc000 = false;
2078 jjtn000.init( className, token.image );
2079 } catch (Throwable jjte000) {
2080 if (jjtc000) {
2081 jjtree.clearNodeScope(jjtn000);
2082 jjtc000 = false;
2083 } else {
2084 jjtree.popNode();
2085 }
2086 if (jjte000 instanceof RuntimeException) {
2087 {if (true) throw (RuntimeException)jjte000;}
2088 }
2089 if (jjte000 instanceof ParseException) {
2090 {if (true) throw (ParseException)jjte000;}
2091 }
2092 {if (true) throw (Error)jjte000;}
2093 } finally {
2094 if (jjtc000) {
2095 jjtree.closeNodeScope(jjtn000, true);
2096 }
2097 }
2098 }
2099
2100 final public void methodCall() throws ParseException {
2101 /*@bgen(jjtree) Method */
2102 ASTMethod jjtn000 = new ASTMethod(JJTMETHOD);
2103 boolean jjtc000 = true;
2104 jjtree.openNodeScope(jjtn000);Token token;
2105 try {
2106 token = jj_consume_token(IDENT);
2107 jj_consume_token(44);
2108 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2109 case 4:
2110 case 28:
2111 case 35:
2112 case 36:
2113 case 40:
2114 case 41:
2115 case 44:
2116 case 46:
2117 case 47:
2118 case 48:
2119 case 49:
2120 case 50:
2121 case 51:
2122 case 52:
2123 case 54:
2124 case 56:
2125 case 57:
2126 case IDENT:
2127 case DYNAMIC_SUBSCRIPT:
2128 case CHAR_LITERAL:
2129 case BACK_CHAR_LITERAL:
2130 case STRING_LITERAL:
2131 case INT_LITERAL:
2132 case FLT_LITERAL:
2133 assignmentExpression();
2134 label_20:
2135 while (true) {
2136 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2137 case 1:
2138 ;
2139 break;
2140 default:
2141 jj_la1[61] = jj_gen;
2142 break label_20;
2143 }
2144 jj_consume_token(1);
2145 assignmentExpression();
2146 }
2147 break;
2148 default:
2149 jj_la1[62] = jj_gen;
2150 ;
2151 }
2152 jj_consume_token(45);
2153 jjtree.closeNodeScope(jjtn000, true);
2154 jjtc000 = false;
2155 jjtn000.setMethodName( token.image );
2156 } catch (Throwable jjte000) {
2157 if (jjtc000) {
2158 jjtree.clearNodeScope(jjtn000);
2159 jjtc000 = false;
2160 } else {
2161 jjtree.popNode();
2162 }
2163 if (jjte000 instanceof RuntimeException) {
2164 {if (true) throw (RuntimeException)jjte000;}
2165 }
2166 if (jjte000 instanceof ParseException) {
2167 {if (true) throw (ParseException)jjte000;}
2168 }
2169 {if (true) throw (Error)jjte000;}
2170 } finally {
2171 if (jjtc000) {
2172 jjtree.closeNodeScope(jjtn000, true);
2173 }
2174 }
2175 }
2176
2177 /**
2178 * Apply an expression to all elements of a collection, creating a new collection
2179 * as the result.
2180 */
2181 final public void projection() throws ParseException {
2182 /*@bgen(jjtree) Project */
2183 ASTProject jjtn000 = new ASTProject(JJTPROJECT);
2184 boolean jjtc000 = true;
2185 jjtree.openNodeScope(jjtn000);
2186 try {
2187 jj_consume_token(54);
2188 expression();
2189 jj_consume_token(55);
2190 } catch (Throwable jjte000) {
2191 if (jjtc000) {
2192 jjtree.clearNodeScope(jjtn000);
2193 jjtc000 = false;
2194 } else {
2195 jjtree.popNode();
2196 }
2197 if (jjte000 instanceof RuntimeException) {
2198 {if (true) throw (RuntimeException)jjte000;}
2199 }
2200 if (jjte000 instanceof ParseException) {
2201 {if (true) throw (ParseException)jjte000;}
2202 }
2203 {if (true) throw (Error)jjte000;}
2204 } finally {
2205 if (jjtc000) {
2206 jjtree.closeNodeScope(jjtn000, true);
2207 }
2208 }
2209 }
2210
2211 final public void selection() throws ParseException {
2212 if (jj_2_14(2)) {
2213 selectAll();
2214 } else if (jj_2_15(2)) {
2215 selectFirst();
2216 } else if (jj_2_16(2)) {
2217 selectLast();
2218 } else {
2219 jj_consume_token(-1);
2220 throw new ParseException();
2221 }
2222 }
2223
2224 /**
2225 * Apply a boolean expression to all elements of a collection, creating a new collection
2226 * containing those elements for which the expression returned true.
2227 */
2228 final public void selectAll() throws ParseException {
2229 /*@bgen(jjtree) Select */
2230 ASTSelect jjtn000 = new ASTSelect(JJTSELECT);
2231 boolean jjtc000 = true;
2232 jjtree.openNodeScope(jjtn000);
2233 try {
2234 jj_consume_token(54);
2235 jj_consume_token(3);
2236 expression();
2237 jj_consume_token(55);
2238 } catch (Throwable jjte000) {
2239 if (jjtc000) {
2240 jjtree.clearNodeScope(jjtn000);
2241 jjtc000 = false;
2242 } else {
2243 jjtree.popNode();
2244 }
2245 if (jjte000 instanceof RuntimeException) {
2246 {if (true) throw (RuntimeException)jjte000;}
2247 }
2248 if (jjte000 instanceof ParseException) {
2249 {if (true) throw (ParseException)jjte000;}
2250 }
2251 {if (true) throw (Error)jjte000;}
2252 } finally {
2253 if (jjtc000) {
2254 jjtree.closeNodeScope(jjtn000, true);
2255 }
2256 }
2257 }
2258
2259 /**
2260 * Apply a boolean expression to all elements of a collection, creating a new collection
2261 * containing those elements for the first element for which the expression returned true.
2262 */
2263 final public void selectFirst() throws ParseException {
2264 /*@bgen(jjtree) SelectFirst */
2265 ASTSelectFirst jjtn000 = new ASTSelectFirst(JJTSELECTFIRST);
2266 boolean jjtc000 = true;
2267 jjtree.openNodeScope(jjtn000);
2268 try {
2269 jj_consume_token(54);
2270 jj_consume_token(11);
2271 expression();
2272 jj_consume_token(55);
2273 } catch (Throwable jjte000) {
2274 if (jjtc000) {
2275 jjtree.clearNodeScope(jjtn000);
2276 jjtc000 = false;
2277 } else {
2278 jjtree.popNode();
2279 }
2280 if (jjte000 instanceof RuntimeException) {
2281 {if (true) throw (RuntimeException)jjte000;}
2282 }
2283 if (jjte000 instanceof ParseException) {
2284 {if (true) throw (ParseException)jjte000;}
2285 }
2286 {if (true) throw (Error)jjte000;}
2287 } finally {
2288 if (jjtc000) {
2289 jjtree.closeNodeScope(jjtn000, true);
2290 }
2291 }
2292 }
2293
2294 /**
2295 * Apply a boolean expression to all elements of a collection, creating a new collection
2296 * containing those elements for the first element for which the expression returned true.
2297 */
2298 final public void selectLast() throws ParseException {
2299 /*@bgen(jjtree) SelectLast */
2300 ASTSelectLast jjtn000 = new ASTSelectLast(JJTSELECTLAST);
2301 boolean jjtc000 = true;
2302 jjtree.openNodeScope(jjtn000);
2303 try {
2304 jj_consume_token(54);
2305 jj_consume_token(58);
2306 expression();
2307 jj_consume_token(55);
2308 } catch (Throwable jjte000) {
2309 if (jjtc000) {
2310 jjtree.clearNodeScope(jjtn000);
2311 jjtc000 = false;
2312 } else {
2313 jjtree.popNode();
2314 }
2315 if (jjte000 instanceof RuntimeException) {
2316 {if (true) throw (RuntimeException)jjte000;}
2317 }
2318 if (jjte000 instanceof ParseException) {
2319 {if (true) throw (ParseException)jjte000;}
2320 }
2321 {if (true) throw (Error)jjte000;}
2322 } finally {
2323 if (jjtc000) {
2324 jjtree.closeNodeScope(jjtn000, true);
2325 }
2326 }
2327 }
2328
2329 final public void index() throws ParseException {
2330 /*@bgen(jjtree) Property */
2331 ASTProperty jjtn000 = new ASTProperty(JJTPROPERTY);
2332 boolean jjtc000 = true;
2333 jjtree.openNodeScope(jjtn000);
2334 try {
2335 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2336 case 52:
2337 jj_consume_token(52);
2338 expression();
2339 jj_consume_token(53);
2340 jjtree.closeNodeScope(jjtn000, true);
2341 jjtc000 = false;
2342 jjtn000.setIndexedAccess(true);
2343 break;
2344 case DYNAMIC_SUBSCRIPT:
2345 jj_consume_token(DYNAMIC_SUBSCRIPT);
2346 ASTConst jjtn001 = new ASTConst(JJTCONST);
2347 boolean jjtc001 = true;
2348 jjtree.openNodeScope(jjtn001);
2349 try {
2350 jjtree.closeNodeScope(jjtn001, true);
2351 jjtc001 = false;
2352 jjtn001.setValue( token_source.literalValue );
2353 } finally {
2354 if (jjtc001) {
2355 jjtree.closeNodeScope(jjtn001, true);
2356 }
2357 }
2358 jjtree.closeNodeScope(jjtn000, true);
2359 jjtc000 = false;
2360 jjtn000.setIndexedAccess(true);
2361 break;
2362 default:
2363 jj_la1[63] = jj_gen;
2364 jj_consume_token(-1);
2365 throw new ParseException();
2366 }
2367 } catch (Throwable jjte000) {
2368 if (jjtc000) {
2369 jjtree.clearNodeScope(jjtn000);
2370 jjtc000 = false;
2371 } else {
2372 jjtree.popNode();
2373 }
2374 if (jjte000 instanceof RuntimeException) {
2375 {if (true) throw (RuntimeException)jjte000;}
2376 }
2377 if (jjte000 instanceof ParseException) {
2378 {if (true) throw (ParseException)jjte000;}
2379 }
2380 {if (true) throw (Error)jjte000;}
2381 } finally {
2382 if (jjtc000) {
2383 jjtree.closeNodeScope(jjtn000, true);
2384 }
2385 }
2386 }
2387
2388 private boolean jj_2_1(int xla) {
2389 jj_la = xla; jj_lastpos = jj_scanpos = token;
2390 try { return !jj_3_1(); }
2391 catch(LookaheadSuccess ls) { return true; }
2392 finally { jj_save(0, xla); }
2393 }
2394
2395 private boolean jj_2_2(int xla) {
2396 jj_la = xla; jj_lastpos = jj_scanpos = token;
2397 try { return !jj_3_2(); }
2398 catch(LookaheadSuccess ls) { return true; }
2399 finally { jj_save(1, xla); }
2400 }
2401
2402 private boolean jj_2_3(int xla) {
2403 jj_la = xla; jj_lastpos = jj_scanpos = token;
2404 try { return !jj_3_3(); }
2405 catch(LookaheadSuccess ls) { return true; }
2406 finally { jj_save(2, xla); }
2407 }
2408
2409 private boolean jj_2_4(int xla) {
2410 jj_la = xla; jj_lastpos = jj_scanpos = token;
2411 try { return !jj_3_4(); }
2412 catch(LookaheadSuccess ls) { return true; }
2413 finally { jj_save(3, xla); }
2414 }
2415
2416 private boolean jj_2_5(int xla) {
2417 jj_la = xla; jj_lastpos = jj_scanpos = token;
2418 try { return !jj_3_5(); }
2419 catch(LookaheadSuccess ls) { return true; }
2420 finally { jj_save(4, xla); }
2421 }
2422
2423 private boolean jj_2_6(int xla) {
2424 jj_la = xla; jj_lastpos = jj_scanpos = token;
2425 try { return !jj_3_6(); }
2426 catch(LookaheadSuccess ls) { return true; }
2427 finally { jj_save(5, xla); }
2428 }
2429
2430 private boolean jj_2_7(int xla) {
2431 jj_la = xla; jj_lastpos = jj_scanpos = token;
2432 try { return !jj_3_7(); }
2433 catch(LookaheadSuccess ls) { return true; }
2434 finally { jj_save(6, xla); }
2435 }
2436
2437 private boolean jj_2_8(int xla) {
2438 jj_la = xla; jj_lastpos = jj_scanpos = token;
2439 try { return !jj_3_8(); }
2440 catch(LookaheadSuccess ls) { return true; }
2441 finally { jj_save(7, xla); }
2442 }
2443
2444 private boolean jj_2_9(int xla) {
2445 jj_la = xla; jj_lastpos = jj_scanpos = token;
2446 try { return !jj_3_9(); }
2447 catch(LookaheadSuccess ls) { return true; }
2448 finally { jj_save(8, xla); }
2449 }
2450
2451 private boolean jj_2_10(int xla) {
2452 jj_la = xla; jj_lastpos = jj_scanpos = token;
2453 try { return !jj_3_10(); }
2454 catch(LookaheadSuccess ls) { return true; }
2455 finally { jj_save(9, xla); }
2456 }
2457
2458 private boolean jj_2_11(int xla) {
2459 jj_la = xla; jj_lastpos = jj_scanpos = token;
2460 try { return !jj_3_11(); }
2461 catch(LookaheadSuccess ls) { return true; }
2462 finally { jj_save(10, xla); }
2463 }
2464
2465 private boolean jj_2_12(int xla) {
2466 jj_la = xla; jj_lastpos = jj_scanpos = token;
2467 try { return !jj_3_12(); }
2468 catch(LookaheadSuccess ls) { return true; }
2469 finally { jj_save(11, xla); }
2470 }
2471
2472 private boolean jj_2_13(int xla) {
2473 jj_la = xla; jj_lastpos = jj_scanpos = token;
2474 try { return !jj_3_13(); }
2475 catch(LookaheadSuccess ls) { return true; }
2476 finally { jj_save(12, xla); }
2477 }
2478
2479 private boolean jj_2_14(int xla) {
2480 jj_la = xla; jj_lastpos = jj_scanpos = token;
2481 try { return !jj_3_14(); }
2482 catch(LookaheadSuccess ls) { return true; }
2483 finally { jj_save(13, xla); }
2484 }
2485
2486 private boolean jj_2_15(int xla) {
2487 jj_la = xla; jj_lastpos = jj_scanpos = token;
2488 try { return !jj_3_15(); }
2489 catch(LookaheadSuccess ls) { return true; }
2490 finally { jj_save(14, xla); }
2491 }
2492
2493 private boolean jj_2_16(int xla) {
2494 jj_la = xla; jj_lastpos = jj_scanpos = token;
2495 try { return !jj_3_16(); }
2496 catch(LookaheadSuccess ls) { return true; }
2497 finally { jj_save(15, xla); }
2498 }
2499
2500 private boolean jj_3R_57() {
2501 if (jj_3R_62()) return true;
2502 return false;
2503 }
2504
2505 private boolean jj_3R_25() {
2506 if (jj_scan_token(IDENT)) return true;
2507 if (jj_scan_token(44)) return true;
2508 return false;
2509 }
2510
2511 private boolean jj_3R_34() {
2512 if (jj_3R_35()) return true;
2513 return false;
2514 }
2515
2516 private boolean jj_3_7() {
2517 if (jj_scan_token(4)) return true;
2518 if (jj_scan_token(52)) return true;
2519 return false;
2520 }
2521
2522 private boolean jj_3_6() {
2523 if (jj_scan_token(51)) return true;
2524 if (jj_scan_token(IDENT)) return true;
2525 return false;
2526 }
2527
2528 private boolean jj_3_5() {
2529 if (jj_scan_token(50)) return true;
2530 return false;
2531 }
2532
2533 private boolean jj_3R_27() {
2534 if (jj_3R_34()) return true;
2535 return false;
2536 }
2537
2538 private boolean jj_3_4() {
2539 if (jj_scan_token(49)) return true;
2540 return false;
2541 }
2542
2543 private boolean jj_3R_65() {
2544 if (jj_scan_token(IDENT)) return true;
2545 return false;
2546 }
2547
2548 private boolean jj_3R_43() {
2549 if (jj_3R_44()) return true;
2550 return false;
2551 }
2552
2553 private boolean jj_3R_56() {
2554 if (jj_scan_token(48)) return true;
2555 return false;
2556 }
2557
2558 private boolean jj_3R_55() {
2559 if (jj_scan_token(47)) return true;
2560 return false;
2561 }
2562
2563 private boolean jj_3R_54() {
2564 if (jj_scan_token(46)) return true;
2565 return false;
2566 }
2567
2568 private boolean jj_3R_31() {
2569 if (jj_3R_27()) return true;
2570 return false;
2571 }
2572
2573 private boolean jj_3_13() {
2574 if (jj_scan_token(52)) return true;
2575 if (jj_3R_27()) return true;
2576 return false;
2577 }
2578
2579 private boolean jj_3R_53() {
2580 Token xsp;
2581 xsp = jj_scanpos;
2582 if (jj_scan_token(73)) {
2583 jj_scanpos = xsp;
2584 if (jj_scan_token(76)) {
2585 jj_scanpos = xsp;
2586 if (jj_scan_token(79)) {
2587 jj_scanpos = xsp;
2588 if (jj_scan_token(80)) {
2589 jj_scanpos = xsp;
2590 if (jj_scan_token(81)) return true;
2591 }
2592 }
2593 }
2594 }
2595 return false;
2596 }
2597
2598 private boolean jj_3R_26() {
2599 if (jj_3R_27()) return true;
2600 return false;
2601 }
2602
2603 private boolean jj_3R_52() {
2604 Token xsp;
2605 xsp = jj_scanpos;
2606 if (jj_3R_53()) {
2607 jj_scanpos = xsp;
2608 if (jj_3R_54()) {
2609 jj_scanpos = xsp;
2610 if (jj_3R_55()) {
2611 jj_scanpos = xsp;
2612 if (jj_3R_56()) {
2613 jj_scanpos = xsp;
2614 if (jj_3_4()) {
2615 jj_scanpos = xsp;
2616 if (jj_3_5()) {
2617 jj_scanpos = xsp;
2618 if (jj_3_6()) {
2619 jj_scanpos = xsp;
2620 if (jj_3_7()) {
2621 jj_scanpos = xsp;
2622 if (jj_3R_57()) {
2623 jj_scanpos = xsp;
2624 if (jj_3_8()) {
2625 jj_scanpos = xsp;
2626 if (jj_3R_58()) {
2627 jj_scanpos = xsp;
2628 if (jj_3R_59()) {
2629 jj_scanpos = xsp;
2630 if (jj_3R_60()) {
2631 jj_scanpos = xsp;
2632 if (jj_3R_61()) {
2633 jj_scanpos = xsp;
2634 if (jj_3_9()) return true;
2635 }
2636 }
2637 }
2638 }
2639 }
2640 }
2641 }
2642 }
2643 }
2644 }
2645 }
2646 }
2647 }
2648 }
2649 return false;
2650 }
2651
2652 private boolean jj_3R_42() {
2653 if (jj_3R_43()) return true;
2654 return false;
2655 }
2656
2657 private boolean jj_3_12() {
2658 if (jj_scan_token(52)) return true;
2659 if (jj_scan_token(53)) return true;
2660 return false;
2661 }
2662
2663 private boolean jj_3_11() {
2664 if (jj_scan_token(44)) return true;
2665 Token xsp;
2666 xsp = jj_scanpos;
2667 if (jj_3R_26()) jj_scanpos = xsp;
2668 if (jj_scan_token(45)) return true;
2669 return false;
2670 }
2671
2672 private boolean jj_3R_67() {
2673 if (jj_scan_token(DYNAMIC_SUBSCRIPT)) return true;
2674 return false;
2675 }
2676
2677 private boolean jj_3_2() {
2678 if (jj_3R_22()) return true;
2679 return false;
2680 }
2681
2682 private boolean jj_3R_66() {
2683 if (jj_scan_token(52)) return true;
2684 return false;
2685 }
2686
2687 private boolean jj_3R_64() {
2688 Token xsp;
2689 xsp = jj_scanpos;
2690 if (jj_3R_66()) {
2691 jj_scanpos = xsp;
2692 if (jj_3R_67()) return true;
2693 }
2694 return false;
2695 }
2696
2697 private boolean jj_3_1() {
2698 if (jj_3R_21()) return true;
2699 return false;
2700 }
2701
2702 private boolean jj_3R_23() {
2703 if (jj_scan_token(57)) return true;
2704 if (jj_3R_32()) return true;
2705 return false;
2706 }
2707
2708 private boolean jj_3R_41() {
2709 if (jj_3R_42()) return true;
2710 return false;
2711 }
2712
2713 private boolean jj_3R_30() {
2714 if (jj_scan_token(54)) return true;
2715 if (jj_scan_token(58)) return true;
2716 return false;
2717 }
2718
2719 private boolean jj_3R_32() {
2720 if (jj_scan_token(IDENT)) return true;
2721 return false;
2722 }
2723
2724 private boolean jj_3R_51() {
2725 if (jj_3R_52()) return true;
2726 return false;
2727 }
2728
2729 private boolean jj_3R_29() {
2730 if (jj_scan_token(54)) return true;
2731 if (jj_scan_token(11)) return true;
2732 return false;
2733 }
2734
2735 private boolean jj_3R_40() {
2736 if (jj_3R_41()) return true;
2737 return false;
2738 }
2739
2740 private boolean jj_3R_33() {
2741 if (jj_scan_token(56)) return true;
2742 return false;
2743 }
2744
2745 private boolean jj_3R_63() {
2746 if (jj_3R_65()) return true;
2747 return false;
2748 }
2749
2750 private boolean jj_3R_28() {
2751 if (jj_scan_token(54)) return true;
2752 if (jj_scan_token(3)) return true;
2753 return false;
2754 }
2755
2756 private boolean jj_3R_50() {
2757 if (jj_3R_51()) return true;
2758 return false;
2759 }
2760
2761 private boolean jj_3R_39() {
2762 if (jj_3R_40()) return true;
2763 return false;
2764 }
2765
2766 private boolean jj_3_10() {
2767 if (jj_3R_25()) return true;
2768 return false;
2769 }
2770
2771 private boolean jj_3R_24() {
2772 if (jj_3R_33()) return true;
2773 return false;
2774 }
2775
2776 private boolean jj_3R_49() {
2777 Token xsp;
2778 xsp = jj_scanpos;
2779 if (jj_scan_token(41)) {
2780 jj_scanpos = xsp;
2781 if (jj_scan_token(28)) return true;
2782 }
2783 return false;
2784 }
2785
2786 private boolean jj_3R_48() {
2787 if (jj_scan_token(40)) return true;
2788 return false;
2789 }
2790
2791 private boolean jj_3_16() {
2792 if (jj_3R_30()) return true;
2793 return false;
2794 }
2795
2796 private boolean jj_3R_47() {
2797 if (jj_scan_token(35)) return true;
2798 return false;
2799 }
2800
2801 private boolean jj_3_15() {
2802 if (jj_3R_29()) return true;
2803 return false;
2804 }
2805
2806 private boolean jj_3R_38() {
2807 if (jj_3R_39()) return true;
2808 return false;
2809 }
2810
2811 private boolean jj_3R_46() {
2812 if (jj_scan_token(36)) return true;
2813 return false;
2814 }
2815
2816 private boolean jj_3_14() {
2817 if (jj_3R_28()) return true;
2818 return false;
2819 }
2820
2821 private boolean jj_3R_62() {
2822 if (jj_3R_33()) return true;
2823 return false;
2824 }
2825
2826 private boolean jj_3R_45() {
2827 Token xsp;
2828 xsp = jj_scanpos;
2829 if (jj_3R_46()) {
2830 jj_scanpos = xsp;
2831 if (jj_3R_47()) {
2832 jj_scanpos = xsp;
2833 if (jj_3R_48()) {
2834 jj_scanpos = xsp;
2835 if (jj_3R_49()) {
2836 jj_scanpos = xsp;
2837 if (jj_3R_50()) return true;
2838 }
2839 }
2840 }
2841 }
2842 return false;
2843 }
2844
2845 private boolean jj_3R_37() {
2846 if (jj_3R_38()) return true;
2847 return false;
2848 }
2849
2850 private boolean jj_3R_22() {
2851 if (jj_scan_token(54)) return true;
2852 if (jj_3R_31()) return true;
2853 return false;
2854 }
2855
2856 private boolean jj_3_9() {
2857 if (jj_scan_token(51)) return true;
2858 Token xsp;
2859 xsp = jj_scanpos;
2860 if (jj_3R_24()) jj_scanpos = xsp;
2861 if (jj_scan_token(54)) return true;
2862 return false;
2863 }
2864
2865 private boolean jj_3R_36() {
2866 if (jj_3R_37()) return true;
2867 return false;
2868 }
2869
2870 private boolean jj_3R_61() {
2871 if (jj_scan_token(54)) return true;
2872 return false;
2873 }
2874
2875 private boolean jj_3R_60() {
2876 if (jj_scan_token(44)) return true;
2877 return false;
2878 }
2879
2880 private boolean jj_3R_59() {
2881 if (jj_3R_64()) return true;
2882 return false;
2883 }
2884
2885 private boolean jj_3_3() {
2886 if (jj_3R_21()) return true;
2887 return false;
2888 }
2889
2890 private boolean jj_3R_21() {
2891 if (jj_scan_token(IDENT)) return true;
2892 if (jj_scan_token(44)) return true;
2893 return false;
2894 }
2895
2896 private boolean jj_3R_58() {
2897 Token xsp;
2898 xsp = jj_scanpos;
2899 if (jj_3_3()) {
2900 jj_scanpos = xsp;
2901 if (jj_3R_63()) return true;
2902 }
2903 return false;
2904 }
2905
2906 private boolean jj_3R_35() {
2907 if (jj_3R_36()) return true;
2908 return false;
2909 }
2910
2911 private boolean jj_3R_44() {
2912 if (jj_3R_45()) return true;
2913 return false;
2914 }
2915
2916 private boolean jj_3_8() {
2917 if (jj_3R_23()) return true;
2918 return false;
2919 }
2920
2921 /** Generated Token Manager. */
2922 public OgnlParserTokenManager token_source;
2923 JavaCharStream jj_input_stream;
2924 /** Current token. */
2925 public Token token;
2926 /** Next token. */
2927 public Token jj_nt;
2928 private int jj_ntk;
2929 private Token jj_scanpos, jj_lastpos;
2930 private int jj_la;
2931 private int jj_gen;
2932 final private int[] jj_la1 = new int[64];
2933 static private int[] jj_la1_0;
2934 static private int[] jj_la1_1;
2935 static private int[] jj_la1_2;
2936 static {
2937 jj_la1_init_0();
2938 jj_la1_init_1();
2939 jj_la1_init_2();
2940 }
2941 private static void jj_la1_init_0() {
2942 jj_la1_0 = new int[] {0x2,0x4,0x8,0x60,0x60,0x180,0x180,0x600,0x600,0x1800,0x1800,0x6000,0x6000,0x78000,0x18000,0x60000,0x78000,0x1ff80000,0x180000,0x600000,0x1800000,0x6000000,0x1ff80000,0xe0000000,0x60000000,0x80000000,0x0,0xe0000000,0x0,0x0,0x0,0x0,0x10000000,0x0,0x0,0x10000010,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x2,0x10000010,0x0,0x2,0x10000010,0x0,0x0,0x0,0x10,0x0,0x0,0x0,0x2,0x10000010,0x2,0x10000010,0x2,0x10000010,0x2,0x10000010,0x0,};
2943 }
2944 private static void jj_la1_init_1() {
2945 jj_la1_1 = new int[] {0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x7,0x0,0x1,0x6,0x7,0x18,0x18,0xe0,0xe0,0x200,0x800,0x400,0x35fd318,0x101800,0x0,0x400000,0x401000,0x101800,0x0,0x0,0x0,0x35fd318,0x1000000,0x0,0x35fd318,0x1c000,0x1000000,0x501000,0x0,0x0,0x0,0x800,0x0,0x35fd318,0x0,0x35fd318,0x0,0x35fd318,0x0,0x35fd318,0x100000,};
2946 }
2947 private static void jj_la1_init_2() {
2948 jj_la1_2 = new int[] {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,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x39209,0x8,0x1,0x0,0x1,0x8,0x39200,0x1,0x0,0x39209,0x0,0x0,0x39209,0x39200,0x0,0x9,0x0,0x1,0x1,0x0,0x0,0x39209,0x0,0x39209,0x0,0x39209,0x0,0x39209,0x8,};
2949 }
2950 final private JJCalls[] jj_2_rtns = new JJCalls[16];
2951 private boolean jj_rescan = false;
2952 private int jj_gc = 0;
2953
2954 /** Constructor with InputStream. */
2955 public OgnlParser(java.io.InputStream stream) {
2956 this(stream, null);
2957 }
2958 /** Constructor with InputStream and supplied encoding */
2959 public OgnlParser(java.io.InputStream stream, String encoding) {
2960 try { jj_input_stream = new JavaCharStream(stream, encoding, 1, 1); } catch(java.io.UnsupportedEncodingException e) { throw new RuntimeException(e); }
2961 token_source = new OgnlParserTokenManager(jj_input_stream);
2962 token = new Token();
2963 jj_ntk = -1;
2964 jj_gen = 0;
2965 for (int i = 0; i < 64; i++) jj_la1[i] = -1;
2966 for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
2967 }
2968
2969 /** Reinitialise. */
2970 public void ReInit(java.io.InputStream stream) {
2971 ReInit(stream, null);
2972 }
2973 /** Reinitialise. */
2974 public void ReInit(java.io.InputStream stream, String encoding) {
2975 try { jj_input_stream.ReInit(stream, encoding, 1, 1); } catch(java.io.UnsupportedEncodingException e) { throw new RuntimeException(e); }
2976 token_source.ReInit(jj_input_stream);
2977 token = new Token();
2978 jj_ntk = -1;
2979 jj_gen = 0;
2980 for (int i = 0; i < 64; i++) jj_la1[i] = -1;
2981 for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
2982 }
2983
2984 /** Constructor. */
2985 public OgnlParser(java.io.Reader stream) {
2986 jj_input_stream = new JavaCharStream(stream, 1, 1);
2987 token_source = new OgnlParserTokenManager(jj_input_stream);
2988 token = new Token();
2989 jj_ntk = -1;
2990 jj_gen = 0;
2991 for (int i = 0; i < 64; i++) jj_la1[i] = -1;
2992 for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
2993 }
2994
2995 /** Reinitialise. */
2996 public void ReInit(java.io.Reader stream) {
2997 jj_input_stream.ReInit(stream, 1, 1);
2998 token_source.ReInit(jj_input_stream);
2999 token = new Token();
3000 jj_ntk = -1;
3001 jj_gen = 0;
3002 for (int i = 0; i < 64; i++) jj_la1[i] = -1;
3003 for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
3004 }
3005
3006 /** Constructor with generated Token Manager. */
3007 public OgnlParser(OgnlParserTokenManager tm) {
3008 token_source = tm;
3009 token = new Token();
3010 jj_ntk = -1;
3011 jj_gen = 0;
3012 for (int i = 0; i < 64; i++) jj_la1[i] = -1;
3013 for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
3014 }
3015
3016 /** Reinitialise. */
3017 public void ReInit(OgnlParserTokenManager tm) {
3018 token_source = tm;
3019 token = new Token();
3020 jj_ntk = -1;
3021 jj_gen = 0;
3022 for (int i = 0; i < 64; i++) jj_la1[i] = -1;
3023 for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
3024 }
3025
3026 private Token jj_consume_token(int kind) throws ParseException {
3027 Token oldToken;
3028 if ((oldToken = token).next != null) token = token.next;
3029 else token = token.next = token_source.getNextToken();
3030 jj_ntk = -1;
3031 if (token.kind == kind) {
3032 jj_gen++;
3033 if (++jj_gc > 100) {
3034 jj_gc = 0;
3035 for (int i = 0; i < jj_2_rtns.length; i++) {
3036 JJCalls c = jj_2_rtns[i];
3037 while (c != null) {
3038 if (c.gen < jj_gen) c.first = null;
3039 c = c.next;
3040 }
3041 }
3042 }
3043 return token;
3044 }
3045 token = oldToken;
3046 jj_kind = kind;
3047 throw generateParseException();
3048 }
3049
3050 static private final class LookaheadSuccess extends java.lang.Error { }
3051 final private LookaheadSuccess jj_ls = new LookaheadSuccess();
3052 private boolean jj_scan_token(int kind) {
3053 if (jj_scanpos == jj_lastpos) {
3054 jj_la--;
3055 if (jj_scanpos.next == null) {
3056 jj_lastpos = jj_scanpos = jj_scanpos.next = token_source.getNextToken();
3057 } else {
3058 jj_lastpos = jj_scanpos = jj_scanpos.next;
3059 }
3060 } else {
3061 jj_scanpos = jj_scanpos.next;
3062 }
3063 if (jj_rescan) {
3064 int i = 0; Token tok = token;
3065 while (tok != null && tok != jj_scanpos) { i++; tok = tok.next; }
3066 if (tok != null) jj_add_error_token(kind, i);
3067 }
3068 if (jj_scanpos.kind != kind) return true;
3069 if (jj_la == 0 && jj_scanpos == jj_lastpos) throw jj_ls;
3070 return false;
3071 }
3072
3073
3074 /** Get the next Token. */
3075 final public Token getNextToken() {
3076 if (token.next != null) token = token.next;
3077 else token = token.next = token_source.getNextToken();
3078 jj_ntk = -1;
3079 jj_gen++;
3080 return token;
3081 }
3082
3083 /** Get the specific Token. */
3084 final public Token getToken(int index) {
3085 Token t = token;
3086 for (int i = 0; i < index; i++) {
3087 if (t.next != null) t = t.next;
3088 else t = t.next = token_source.getNextToken();
3089 }
3090 return t;
3091 }
3092
3093 private int jj_ntk() {
3094 if ((jj_nt=token.next) == null)
3095 return (jj_ntk = (token.next=token_source.getNextToken()).kind);
3096 else
3097 return (jj_ntk = jj_nt.kind);
3098 }
3099
3100 private java.util.List<int[]> jj_expentries = new java.util.ArrayList<int[]>();
3101 private int[] jj_expentry;
3102 private int jj_kind = -1;
3103 private int[] jj_lasttokens = new int[100];
3104 private int jj_endpos;
3105
3106 private void jj_add_error_token(int kind, int pos) {
3107 if (pos >= 100) return;
3108 if (pos == jj_endpos + 1) {
3109 jj_lasttokens[jj_endpos++] = kind;
3110 } else if (jj_endpos != 0) {
3111 jj_expentry = new int[jj_endpos];
3112 for (int i = 0; i < jj_endpos; i++) {
3113 jj_expentry[i] = jj_lasttokens[i];
3114 }
3115 jj_entries_loop: for (java.util.Iterator<?> it = jj_expentries.iterator(); it.hasNext();) {
3116 int[] oldentry = (int[])(it.next());
3117 if (oldentry.length == jj_expentry.length) {
3118 for (int i = 0; i < jj_expentry.length; i++) {
3119 if (oldentry[i] != jj_expentry[i]) {
3120 continue jj_entries_loop;
3121 }
3122 }
3123 jj_expentries.add(jj_expentry);
3124 break jj_entries_loop;
3125 }
3126 }
3127 if (pos != 0) jj_lasttokens[(jj_endpos = pos) - 1] = kind;
3128 }
3129 }
3130
3131 /** Generate ParseException. */
3132 public ParseException generateParseException() {
3133 jj_expentries.clear();
3134 boolean[] la1tokens = new boolean[86];
3135 if (jj_kind >= 0) {
3136 la1tokens[jj_kind] = true;
3137 jj_kind = -1;
3138 }
3139 for (int i = 0; i < 64; i++) {
3140 if (jj_la1[i] == jj_gen) {
3141 for (int j = 0; j < 32; j++) {
3142 if ((jj_la1_0[i] & (1<<j)) != 0) {
3143 la1tokens[j] = true;
3144 }
3145 if ((jj_la1_1[i] & (1<<j)) != 0) {
3146 la1tokens[32+j] = true;
3147 }
3148 if ((jj_la1_2[i] & (1<<j)) != 0) {
3149 la1tokens[64+j] = true;
3150 }
3151 }
3152 }
3153 }
3154 for (int i = 0; i < 86; i++) {
3155 if (la1tokens[i]) {
3156 jj_expentry = new int[1];
3157 jj_expentry[0] = i;
3158 jj_expentries.add(jj_expentry);
3159 }
3160 }
3161 jj_endpos = 0;
3162 jj_rescan_token();
3163 jj_add_error_token(0, 0);
3164 int[][] exptokseq = new int[jj_expentries.size()][];
3165 for (int i = 0; i < jj_expentries.size(); i++) {
3166 exptokseq[i] = jj_expentries.get(i);
3167 }
3168 return new ParseException(token, exptokseq, tokenImage);
3169 }
3170
3171 /** Enable tracing. */
3172 final public void enable_tracing() {
3173 }
3174
3175 /** Disable tracing. */
3176 final public void disable_tracing() {
3177 }
3178
3179 private void jj_rescan_token() {
3180 jj_rescan = true;
3181 for (int i = 0; i < 16; i++) {
3182 try {
3183 JJCalls p = jj_2_rtns[i];
3184 do {
3185 if (p.gen > jj_gen) {
3186 jj_la = p.arg; jj_lastpos = jj_scanpos = p.first;
3187 switch (i) {
3188 case 0: jj_3_1(); break;
3189 case 1: jj_3_2(); break;
3190 case 2: jj_3_3(); break;
3191 case 3: jj_3_4(); break;
3192 case 4: jj_3_5(); break;
3193 case 5: jj_3_6(); break;
3194 case 6: jj_3_7(); break;
3195 case 7: jj_3_8(); break;
3196 case 8: jj_3_9(); break;
3197 case 9: jj_3_10(); break;
3198 case 10: jj_3_11(); break;
3199 case 11: jj_3_12(); break;
3200 case 12: jj_3_13(); break;
3201 case 13: jj_3_14(); break;
3202 case 14: jj_3_15(); break;
3203 case 15: jj_3_16(); break;
3204 }
3205 }
3206 p = p.next;
3207 } while (p != null);
3208 } catch(LookaheadSuccess ls) { }
3209 }
3210 jj_rescan = false;
3211 }
3212
3213 private void jj_save(int index, int xla) {
3214 JJCalls p = jj_2_rtns[index];
3215 while (p.gen > jj_gen) {
3216 if (p.next == null) { p = p.next = new JJCalls(); break; }
3217 p = p.next;
3218 }
3219 p.gen = jj_gen + xla - jj_la; p.first = token; p.arg = xla;
3220 }
3221
3222 static final class JJCalls {
3223 int gen;
3224 Token first;
3225 int arg;
3226 JJCalls next;
3227 }
3228
3229 }