|
1
16
17 package org.apache.commons.jexl.parser;
18
19 import java.io.Reader  ;
20
21 public class Parserimplements ParserTreeConstants, ParserConstants {
22 protected JJTParserState jjtree = new JJTParserState();
23
24 public SimpleNode parse(Reader reader) throws Exception {
25 ReInit(reader);
26
27
31
32 SimpleNode tree = JexlScript();
33 return tree;
34 }
35
36
39 public final SimpleNode JexlScript() throws ParseException {
40
41 ASTJexlScript jjtn000 = new ASTJexlScript(this, JJTJEXLSCRIPT);
42 boolean jjtc000 = true;
43 jjtree.openNodeScope(jjtn000);
44 String name;
45 try {
46 label_1: while (true) {
47 switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
48 case INTEGER_LITERAL:
49 case FLOAT_LITERAL:
50 case 9:
51 case 11:
52 case 12:
53 case 14:
54 case 36:
55 case 42:
56 case 43:
57 case 44:
58 case 45:
59 case 46:
60 case 47:
61 case 48:
62 case 49:
63 case 51:
64 case 52:
65 case IDENTIFIER:
66 case STRING_LITERAL:
67 ;
68 break;
69 default:
70 jj_la1[0] = jj_gen;
71 break label_1;
72 }
73 Statement();
74 }
75 jj_consume_token(0);
76 jjtree.closeNodeScope(jjtn000, true);
77 jjtc000 = false;
78 {
79 if (true)
80 return jjtn000;
81 }
82 } catch (Throwable jjte000) {
83 if (jjtc000) {
84 jjtree.clearNodeScope(jjtn000);
85 jjtc000 = false;
86 } else {
87 jjtree.popNode();
88 }
89 if (jjte000 instanceof RuntimeException ) {
90 {
91 if (true)
92 throw (RuntimeException ) jjte000;
93 }
94 }
95 if (jjte000 instanceof ParseException) {
96 {
97 if (true)
98 throw (ParseException) jjte000;
99 }
100 }
101 {
102 if (true)
103 throw (Error ) jjte000;
104 }
105 } finally {
106 if (jjtc000) {
107 jjtree.closeNodeScope(jjtn000, true);
108 }
109 }
110 throw new Error ("Missing return statement in function");
111 }
112
113 final public void Block() throws ParseException {
114
115 ASTBlock jjtn000 = new ASTBlock(this, JJTBLOCK);
116 boolean jjtc000 = true;
117 jjtree.openNodeScope(jjtn000);
118 try {
119 jj_consume_token(9);
120 label_2: while (true) {
121 switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
122 case INTEGER_LITERAL:
123 case FLOAT_LITERAL:
124 case 9:
125 case 11:
126 case 12:
127 case 14:
128 case 36:
129 case 42:
130 case 43:
131 case 44:
132 case 45:
133 case 46:
134 case 47:
135 case 48:
136 case 49:
137 case 51:
138 case 52:
139 case IDENTIFIER:
140 case STRING_LITERAL:
141 ;
142 break;
143 default:
144 jj_la1[1] = jj_gen;
145 break label_2;
146 }
147 Statement();
148 }
149 jj_consume_token(10);
150 } catch (Throwable jjte000) {
151 if (jjtc000) {
152 jjtree.clearNodeScope(jjtn000);
153 jjtc000 = false;
154 } else {
155 jjtree.popNode();
156 }
157 if (jjte000 instanceof RuntimeException ) {
158 {
159 if (true)
160 throw (RuntimeException ) jjte000;
161 }
162 }
163 if (jjte000 instanceof ParseException) {
164 {
165 if (true)
166 throw (ParseException) jjte000;
167 }
168 }
169 {
170 if (true)
171 throw (Error ) jjte000;
172 }
173 } finally {
174 if (jjtc000) {
175 jjtree.closeNodeScope(jjtn000, true);
176 }
177 }
178 }
179
180 final public void EmptyFunction() throws ParseException {
181
182 ASTEmptyFunction jjtn000 = new ASTEmptyFunction(this, JJTEMPTYFUNCTION);
183 boolean jjtc000 = true;
184 jjtree.openNodeScope(jjtn000);
185 try {
186 jj_consume_token(11);
187 switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
188 case IDENTIFIER:
189 Reference();
190 break;
191 case 12:
192 jj_consume_token(12);
193 Reference();
194 jj_consume_token(13);
195 break;
196 default:
197 jj_la1[2] = jj_gen;
198 jj_consume_token(-1);
199 throw new ParseException();
200 }
201 } catch (Throwable jjte000) {
202 if (jjtc000) {
203 jjtree.clearNodeScope(jjtn000);
204 jjtc000 = false;
205 } else {
206 jjtree.popNode();
207 }
208 if (jjte000 instanceof RuntimeException ) {
209 {
210 if (true)
211 throw (RuntimeException ) jjte000;
212 }
213 }
214 if (jjte000 instanceof ParseException) {
215 {
216 if (true)
217 throw (ParseException) jjte000;
218 }
219 }
220 {
221 if (true)
222 throw (Error ) jjte000;
223 }
224 } finally {
225 if (jjtc000) {
226 jjtree.closeNodeScope(jjtn000, true);
227 }
228 }
229 }
230
231 final public void SizeFunction() throws ParseException {
232
233 ASTSizeFunction jjtn000 = new ASTSizeFunction(this, JJTSIZEFUNCTION);
234 boolean jjtc000 = true;
235 jjtree.openNodeScope(jjtn000);
236 try {
237 jj_consume_token(14);
238 jj_consume_token(12);
239 Reference();
240 jj_consume_token(13);
241 } catch (Throwable jjte000) {
242 if (jjtc000) {
243 jjtree.clearNodeScope(jjtn000);
244 jjtc000 = false;
245 } else {
246 jjtree.popNode();
247 }
248 if (jjte000 instanceof RuntimeException ) {
249 {
250 if (true)
251 throw (RuntimeException ) jjte000;
252 }
253 }
254 if (jjte000 instanceof ParseException) {
255 {
256 if (true)
257 throw (ParseException) jjte000;
258 }
259 }
260 {
261 if (true)
262 throw (Error ) jjte000;
263 }
264 } finally {
265 if (jjtc000) {
266 jjtree.closeNodeScope(jjtn000, true);
267 }
268 }
269 }
270
271 final public void Identifier() throws ParseException {
272
273 ASTIdentifier jjtn000 = new ASTIdentifier(this, JJTIDENTIFIER);
274 boolean jjtc000 = true;
275 jjtree.openNodeScope(jjtn000);
276 Token t;
277 try {
278 t = jj_consume_token(IDENTIFIER);
279 jjtree.closeNodeScope(jjtn000, true);
280 jjtc000 = false;
281 jjtn000.val = t.image;
282 } finally {
283 if (jjtc000) {
284 jjtree.closeNodeScope(jjtn000, true);
285 }
286 }
287 }
288
289
292 final public void Expression() throws ParseException {
293
294 ASTExpression jjtn000 = new ASTExpression(this, JJTEXPRESSION);
295 boolean jjtc000 = true;
296 jjtree.openNodeScope(jjtn000);
297 try {
298 if (jj_2_1(2147483647)) {
299 Assignment();
300 } else {
301 switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
302 case INTEGER_LITERAL:
303 case FLOAT_LITERAL:
304 case 11:
305 case 12:
306 case 14:
307 case 36:
308 case 42:
309 case 43:
310 case 44:
311 case 45:
312 case 46:
313 case 47:
314 case IDENTIFIER:
315 case STRING_LITERAL:
316 ConditionalOrExpression();
317 break;
318 default:
319 jj_la1[3] = jj_gen;
320 jj_consume_token(-1);
321 throw new ParseException();
322 }
323 }
324 } catch (Throwable jjte000) {
325 if (jjtc000) {
326 jjtree.clearNodeScope(jjtn000);
327 jjtc000 = false;
328 } else {
329 jjtree.popNode();
330 }
331 if (jjte000 instanceof RuntimeException ) {
332 {
333 if (true)
334 throw (RuntimeException ) jjte000;
335 }
336 }
337 if (jjte000 instanceof ParseException) {
338 {
339 if (true)
340 throw (ParseException) jjte000;
341 }
342 }
343 {
344 if (true)
345 throw (Error ) jjte000;
346 }
347 } finally {
348 if (jjtc000) {
349 jjtree.closeNodeScope(jjtn000, true);
350 }
351 }
352 }
353
354 final public void Assignment() throws ParseException {
355
356 ASTAssignment jjtn000 = new ASTAssignment(this, JJTASSIGNMENT);
357 boolean jjtc000 = true;
358 jjtree.openNodeScope(jjtn000);
359 try {
360 PrimaryExpression();
361 jj_consume_token(15);
362 Expression();
363 } catch (Throwable jjte000) {
364 if (jjtc000) {
365 jjtree.clearNodeScope(jjtn000);
366 jjtc000 = false;
367 } else {
368 jjtree.popNode();
369 }
370 if (jjte000 instanceof RuntimeException ) {
371 {
372 if (true)
373 throw (RuntimeException ) jjte000;
374 }
375 }
376 if (jjte000 instanceof ParseException) {
377 {
378 if (true)
379 throw (ParseException) jjte000;
380 }
381 }
382 {
383 if (true)
384 throw (Error ) jjte000;
385 }
386 } finally {
387 if (jjtc000) {
388 jjtree.closeNodeScope(jjtn000, 2);
389 }
390 }
391 }
392
393 final public void ConditionalOrExpression() throws ParseException {
394 ConditionalAndExpression();
395 label_3: while (true) {
396 switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
397 case 16:
398 case 17:
399 ;
400 break;
401 default:
402 jj_la1[4] = jj_gen;
403 break label_3;
404 }
405 switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
406 case 16:
407 jj_consume_token(16);
408 ASTOrNode jjtn001 = new ASTOrNode(this, JJTORNODE);
409 boolean jjtc001 = true;
410 jjtree.openNodeScope(jjtn001);
411 try {
412 ConditionalAndExpression();
413 } catch (Throwable jjte001) {
414 if (jjtc001) {
415 jjtree.clearNodeScope(jjtn001);
416 jjtc001 = false;
417 } else {
418 jjtree.popNode();
419 }
420 if (jjte001 instanceof RuntimeException ) {
421 {
422 if (true)
423 throw (RuntimeException ) jjte001;
424 }
425 }
426 if (jjte001 instanceof ParseException) {
427 {
428 if (true)
429 throw (ParseException) jjte001;
430 }
431 }
432 {
433 if (true)
434 throw (Error ) jjte001;
435 }
436 } finally {
437 if (jjtc001) {
438 jjtree.closeNodeScope(jjtn001, 2);
439 }
440 }
441 break;
442 case 17:
443 jj_consume_token(17);
444 ASTOrNode jjtn002 = new ASTOrNode(this, JJTORNODE);
445 boolean jjtc002 = true;
446 jjtree.openNodeScope(jjtn002);
447 try {
448 ConditionalAndExpression();
449 } catch (Throwable jjte002) {
450 if (jjtc002) {
451 jjtree.clearNodeScope(jjtn002);
452 jjtc002 = false;
453 } else {
454 jjtree.popNode();
455 }
456 if (jjte002 instanceof RuntimeException ) {
457 {
458 if (true)
459 throw (RuntimeException ) jjte002;
460 }
461 }
462 if (jjte002 instanceof ParseException) {
463 {
464 if (true)
465 throw (ParseException) jjte002;
466 }
467 }
468 {
469 if (true)
470 throw (Error ) jjte002;
471 }
472 } finally {
473 if (jjtc002) {
474 jjtree.closeNodeScope(jjtn002, 2);
475 }
476 }
477 break;
478 default:
479 jj_la1[5] = jj_gen;
480 jj_consume_token(-1);
481 throw new ParseException();
482 }
483 }
484 }
485
486 final public void ConditionalAndExpression() throws ParseException {
487 InclusiveOrExpression();
488 label_4: while (true) {
489 switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
490 case 18:
491 case 19:
492 ;
493 break;
494 default:
495 jj_la1[6] = jj_gen;
496 break label_4;
497 }
498 switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
499 case 18:
500 jj_consume_token(18);
501 ASTAndNode jjtn001 = new ASTAndNode(this, JJTANDNODE);
502 boolean jjtc001 = true;
503 jjtree.openNodeScope(jjtn001);
504 try {
505 InclusiveOrExpression();
506 } catch (Throwable jjte001) {
507 if (jjtc001) {
508 jjtree.clearNodeScope(jjtn001);
509 jjtc001 = false;
510 } else {
511 jjtree.popNode();
512 }
513 if (jjte001 instanceof RuntimeException ) {
514 {
515 if (true)
516 throw (RuntimeException ) jjte001;
517 }
518 }
519 if (jjte001 instanceof ParseException) {
520 {
521 if (true)
522 throw (ParseException) jjte001;
523 }
524 }
525 {
526 if (true)
527 throw (Error ) jjte001;
528 }
529 } finally {
530 if (jjtc001) {
531 jjtree.closeNodeScope(jjtn001, 2);
532 }
533 }
534 break;
535 case 19:
536 jj_consume_token(19);
537 ASTAndNode jjtn002 = new ASTAndNode(this, JJTANDNODE);
538 boolean jjtc002 = true;
539 jjtree.openNodeScope(jjtn002);
540 try {
541 InclusiveOrExpression();
542 } catch (Throwable jjte002) {
543 if (jjtc002) {
544 jjtree.clearNodeScope(jjtn002);
545 jjtc002 = false;
546 } else {
547 jjtree.popNode();
548 }
549 if (jjte002 instanceof RuntimeException ) {
550 {
551 if (true)
552 throw (RuntimeException ) jjte002;
553 }
554 }
555 if (jjte002 instanceof ParseException) {
556 {
557 if (true)
558 throw (ParseException) jjte002;
559 }
560 }
561 {
562 if (true)
563 throw (Error ) jjte002;
564 }
565 } finally {
566 if (jjtc002) {
567 jjtree.closeNodeScope(jjtn002, 2);
568 }
569 }
570 break;
571 default:
572 jj_la1[7] = jj_gen;
573 jj_consume_token(-1);
574 throw new ParseException();
575 }
576 }
577 }
578
579 final public void InclusiveOrExpression() throws ParseException {
580 ExclusiveOrExpression();
581 label_5: while (true) {
582 switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
583 case 20:
584 ;
585 break;
586 default:
587 jj_la1[8] = jj_gen;
588 break label_5;
589 }
590 jj_consume_token(20);
591 ASTBitwiseOrNode jjtn001 = new ASTBitwiseOrNode(this, JJTBITWISEORNODE);
592 boolean jjtc001 = true;
593 jjtree.openNodeScope(jjtn001);
594 try {
595 ExclusiveOrExpression();
596 } catch (Throwable jjte001) {
597 if (jjtc001) {
598 jjtree.clearNodeScope(jjtn001);
599 jjtc001 = false;
600 } else {
601 jjtree.popNode();
602 }
603 if (jjte001 instanceof RuntimeException ) {
604 {
605 if (true)
606 throw (RuntimeException ) jjte001;
607 }
608 }
609 if (jjte001 instanceof ParseException) {
610 {
611 if (true)
612 throw (ParseException) jjte001;
613 }
614 }
615 {
616 if (true)
617 throw (Error ) jjte001;
618 }
619 } finally {
620 if (jjtc001) {
621 jjtree.closeNodeScope(jjtn001, 2);
622 }
623 }
624 }
625 }
626
627 final public void ExclusiveOrExpression() throws ParseException {
628 AndExpression();
629 label_6: while (true) {
630 switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
631 case 21:
632 ;
633 break;
634 default:
635 jj_la1[9] = jj_gen;
636 break label_6;
637 }
638 jj_consume_token(21);
639 ASTBitwiseXorNode jjtn001 = new ASTBitwiseXorNode(this, JJTBITWISEXORNODE);
640 boolean jjtc001 = true;
641 jjtree.openNodeScope(jjtn001);
642 try {
643 AndExpression();
644 } catch (Throwable jjte001) {
645 if (jjtc001) {
646 jjtree.clearNodeScope(jjtn001);
647 jjtc001 = false;
648 } else {
649 jjtree.popNode();
650 }
651 if (jjte001 instanceof RuntimeException ) {
652 {
653 if (true)
654 throw (RuntimeException ) jjte001;
655 }
656 }
657 if (jjte001 instanceof ParseException) {
658 {
659 if (true)
660 throw (ParseException) jjte001;
661 }
662 }
663 {
664 if (true)
665 throw (Error ) jjte001;
666 }
667 } finally {
668 if (jjtc001) {
669 jjtree.closeNodeScope(jjtn001, 2);
670 }
671 }
672 }
673 }
674
675 final public void AndExpression() throws ParseException {
676 EqualityExpression();
677 label_7: while (true) {
678 switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
679 case 22:
680 ;
681 break;
682 default:
683 jj_la1[10] = jj_gen;
684 break label_7;
685 }
686 jj_consume_token(22);
687 ASTBitwiseAndNode jjtn001 = new ASTBitwiseAndNode(this, JJTBITWISEANDNODE);
688 boolean jjtc001 = true;
689 jjtree.openNodeScope(jjtn001);
690 try {
691 EqualityExpression();
692 } catch (Throwable jjte001) {
693 if (jjtc001) {
694 jjtree.clearNodeScope(jjtn001);
695 jjtc001 = false;
696 } else {
697 jjtree.popNode();
698 }
699 if (jjte001 instanceof RuntimeException ) {
700 {
701 if (true)
702 throw (RuntimeException ) jjte001;
703 }
704 }
705 if (jjte001 instanceof ParseException) {
706 {
707 if (true)
708 throw (ParseException) jjte001;
709 }
710 }
711 {
712 if (true)
713 throw (Error ) jjte001;
714 }
715 } finally {
716 if (jjtc001) {
717 jjtree.closeNodeScope(jjtn001, 2);
718 }
719 }
720 }
721 }
722
723 final public void EqualityExpression() throws ParseException {
724 RelationalExpression();
725 label_8: while (true) {
726 switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
727 case 23:
728 case 24:
729 case 25:
730 case 26:
731 ;
732 break;
733 default:
734 jj_la1[11] = jj_gen;
735 break label_8;
736 }
737 switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
738 case 23:
739 jj_consume_token(23);
740 ASTEQNode jjtn001 = new ASTEQNode(this, JJTEQNODE);
741 boolean jjtc001 = true;
742 jjtree.openNodeScope(jjtn001);
743 try {
744 RelationalExpression();
745 } catch (Throwable jjte001) {
746 if (jjtc001) {
747 jjtree.clearNodeScope(jjtn001);
748 jjtc001 = false;
749 } else {
750 jjtree.popNode();
751 }
752 if (jjte001 instanceof RuntimeException ) {
753 {
754 if (true)
755 throw (RuntimeException ) jjte001;
756 }
757 }
758 if (jjte001 instanceof ParseException) {
759 {
760 if (true)
761 throw (ParseException) jjte001;
762 }
763 }
764 {
765 if (true)
766 throw (Error ) jjte001;
767 }
768 } finally {
769 if (jjtc001) {
770 jjtree.closeNodeScope(jjtn001, 2);
771 }
772 }
773 break;
774 case 24:
775 jj_consume_token(24);
776 ASTEQNode jjtn002 = new ASTEQNode(this, JJTEQNODE);
777 boolean jjtc002 = true;
778 jjtree.openNodeScope(jjtn002);
779 try {
780 RelationalExpression();
781 } catch (Throwable jjte002) {
782 if (jjtc002) {
783 jjtree.clearNodeScope(jjtn002);
784 jjtc002 = false;
785 } else {
786 jjtree.popNode();
787 }
788 if (jjte002 instanceof RuntimeException ) {
789 {
790 if (true)
791 throw (RuntimeException ) jjte002;
792 }
793 }
794 if (jjte002 instanceof ParseException) {
795 {
796 if (true)
797 throw (ParseException) jjte002;
798 }
799 }
800 {
801 if (true)
802 throw (Error ) jjte002;
803 }
804 } finally {
805 if (jjtc002) {
806 jjtree.closeNodeScope(jjtn002, 2);
807 }
808 }
809 break;
810 case 25:
811 jj_consume_token(25);
812 ASTNENode jjtn003 = new ASTNENode(this, JJTNENODE);
813 boolean jjtc003 = true;
814 jjtree.openNodeScope(jjtn003);
815 try {
816 RelationalExpression();
817 } catch (Throwable jjte003) {
818 if (jjtc003) {
819 jjtree.clearNodeScope(jjtn003);
820 jjtc003 = false;
821 } else {
822 jjtree.popNode();
823 }
824 if (jjte003 instanceof RuntimeException ) {
825 {
826 if (true)
827 throw (RuntimeException ) jjte003;
828 }
829 }
830 if (jjte003 instanceof ParseException) {
831 {
832 if (true)
833 throw (ParseException) jjte003;
834 }
835 }
836 {
837 if (true)
838 throw (Error ) jjte003;
839 }
840 } finally {
841 if (jjtc003) {
842 jjtree.closeNodeScope(jjtn003, 2);
843 }
844 }
845 break;
846 case 26:
847 jj_consume_token(26);
848 ASTNENode jjtn004 = new ASTNENode(this, JJTNENODE);
849 boolean jjtc004 = true;
850 jjtree.openNodeScope(jjtn004);
851 try {
852 RelationalExpression();
853 } catch (Throwable jjte004) {
854 if (jjtc004) {
855 jjtree.clearNodeScope(jjtn004);
856 jjtc004 = false;
857 } else {
858 jjtree.popNode();
859 }
860 if (jjte004 instanceof RuntimeException ) {
861 {
862 if (true)
863 throw (RuntimeException ) jjte004;
864 }
865 }
866 if (jjte004 instanceof ParseException) {
867 {
868 if (true)
869 throw (ParseException) jjte004;
870 }
871 }
872 {
873 if (true)
874 throw (Error ) jjte004;
875 }
876 } finally {
877 if (jjtc004) {
878 jjtree.closeNodeScope(jjtn004, 2);
879 }
880 }
881 break;
882 default:
883 jj_la1[12] = jj_gen;
884 jj_consume_token(-1);
885 throw new ParseException();
886 }
887 }
888 }
889
890 final public void RelationalExpression() throws ParseException {
891 AdditiveExpression();
892 label_9: while (true) {
893 switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
894 case 27:
895 case 28:
896 case 29:
897 case 30:
898 case 31:
899 case 32:
900 case 33:
901 case 34:
902 ;
903 break;
904 default:
905 jj_la1[13] = jj_gen;
906 break label_9;
907 }
908 switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
909 case 27:
910 jj_consume_token(27);
911 ASTLTNode jjtn001 = new ASTLTNode(this, JJTLTNODE);
912 boolean jjtc001 = true;
913 jjtree.openNodeScope(jjtn001);
914 try {
915 AdditiveExpression();
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 {
925 if (true)
926 throw (RuntimeException ) jjte001;
927 }
928 }
929 if (jjte001 instanceof ParseException) {
930 {
931 if (true)
932 throw (ParseException) jjte001;
933 }
934 }
935 {
936 if (true)
937 throw (Error ) jjte001;
938 }
939 } finally {
940 if (jjtc001) {
941 jjtree.closeNodeScope(jjtn001, 2);
942 }
943 }
944 break;
945 case 28:
946 jj_consume_token(28);
947 ASTLTNode jjtn002 = new ASTLTNode(this, JJTLTNODE);
948 boolean jjtc002 = true;
949 jjtree.openNodeScope(jjtn002);
950 try {
951 AdditiveExpression();
952 } catch (Throwable jjte002) {
953 if (jjtc002) {
954 jjtree.clearNodeScope(jjtn002);
955 jjtc002 = false;
956 } else {
957 jjtree.popNode();
958 }
959 if (jjte002 instanceof RuntimeException ) {
960 {
961 if (true)
962 throw (RuntimeException ) jjte002;
963 }
964 }
965 if (jjte002 instanceof ParseException) {
966 {
967 if (true)
968 throw (ParseException) jjte002;
969 }
970 }
971 {
972 if (true)
973 throw (Error ) jjte002;
974 }
975 } finally {
976 if (jjtc002) {
977 jjtree.closeNodeScope(jjtn002, 2);
978 }
979 }
980 break;
981 case 29:
982 jj_consume_token(29);
983 ASTGTNode jjtn003 = new ASTGTNode(this, JJTGTNODE);
984 boolean jjtc003 = true;
985 jjtree.openNodeScope(jjtn003);
986 try {
987 AdditiveExpression();
988 } catch (Throwable jjte003) {
989 if (jjtc003) {
990 jjtree.clearNodeScope(jjtn003);
991 jjtc003 = false;
992 } else {
993 jjtree.popNode();
994 }
995 if (jjte003 instanceof RuntimeException ) {
996 {
997 if (true)
998 throw (RuntimeException ) jjte003;
999 }
1000 }
1001 if (jjte003 instanceof ParseException) {
1002 {
1003 if (true)
1004 throw (ParseException) jjte003;
1005 }
1006 }
1007 {
1008 if (true)
1009 throw (Error ) jjte003;
1010 }
1011 } finally {
1012 if (jjtc003) {
1013 jjtree.closeNodeScope(jjtn003, 2);
1014 }
1015 }
1016 break;
1017 case 30:
1018 jj_consume_token(30);
1019 ASTGTNode jjtn004 = new ASTGTNode(this, JJTGTNODE);
1020 boolean jjtc004 = true;
1021 jjtree.openNodeScope(jjtn004);
1022 try {
1023 AdditiveExpression();
1024 } catch (Throwable jjte004) {
1025 if (jjtc004) {
1026 jjtree.clearNodeScope(jjtn004);
1027 jjtc004 = false;
1028 } else {
1029 jjtree.popNode();
1030 }
1031 if (jjte004 instanceof RuntimeException ) {
1032 {
1033 if (true)
1034 throw (RuntimeException ) jjte004;
1035 }
1036 }
1037 if (jjte004 instanceof ParseException) {
1038 {
1039 if (true)
1040 throw (ParseException) jjte004;
1041 }
1042 }
1043 {
1044 if (true)
1045 throw (Error ) jjte004;
1046 }
1047 } finally {
1048 if (jjtc004) {
1049 jjtree.closeNodeScope(jjtn004, 2);
1050 }
1051 }
1052 break;
1053 case 31:
1054 jj_consume_token(31);
1055 ASTLENode jjtn005 = new ASTLENode(this, JJTLENODE);
1056 boolean jjtc005 = true;
1057 jjtree.openNodeScope(jjtn005);
1058 try {
1059 AdditiveExpression();
1060 } catch (Throwable jjte005) {
1061 if (jjtc005) {
1062 jjtree.clearNodeScope(jjtn005);
1063 jjtc005 = false;
1064 } else {
1065 jjtree.popNode();
1066 }
1067 if (jjte005 instanceof RuntimeException ) {
1068 {
1069 if (true)
1070 throw (RuntimeException ) jjte005;
1071 }
1072 }
1073 if (jjte005 instanceof ParseException) {
1074 {
1075 if (true)
1076 throw (ParseException) jjte005;
1077 }
1078 }
1079 {
1080 if (true)
1081 throw (Error ) jjte005;
1082 }
1083 } finally {
1084 if (jjtc005) {
1085 jjtree.closeNodeScope(jjtn005, 2);
1086 }
1087 }
1088 break;
1089 case 32:
1090 jj_consume_token(32);
1091 ASTLENode jjtn006 = new ASTLENode(this, JJTLENODE);
1092 boolean jjtc006 = true;
1093 jjtree.openNodeScope(jjtn006);
1094 try {
1095 AdditiveExpression();
1096 } catch (Throwable jjte006) {
1097 if (jjtc006) {
1098 jjtree.clearNodeScope(jjtn006);
1099 jjtc006 = false;
1100 } else {
1101 jjtree.popNode();
1102 }
1103 if (jjte006 instanceof RuntimeException ) {
1104 {
1105 if (true)
1106 throw (RuntimeException ) jjte006;
1107 }
1108 }
1109 if (jjte006 instanceof ParseException) {
1110 {
1111 if (true)
1112 throw (ParseException) jjte006;
1113 }
1114 }
1115 {
1116 if (true)
1117 throw (Error ) jjte006;
1118 }
1119 } finally {
1120 if (jjtc006) {
1121 jjtree.closeNodeScope(jjtn006, 2);
1122 }
1123 }
1124 break;
1125 case 33:
1126 jj_consume_token(33);
1127 ASTGENode jjtn007 = new ASTGENode(this, JJTGENODE);
1128 boolean jjtc007 = true;
1129 jjtree.openNodeScope(jjtn007);
1130 try {
1131 AdditiveExpression();
1132 } catch (Throwable jjte007) {
1133 if (jjtc007) {
1134 jjtree.clearNodeScope(jjtn007);
1135 jjtc007 = false;
1136 } else {
1137 jjtree.popNode();
1138 }
1139 if (jjte007 instanceof RuntimeException ) {
1140 {
1141 if (true)
1142 throw (RuntimeException ) jjte007;
1143 }
1144 }
1145 if (jjte007 instanceof ParseException) {
1146 {
1147 if (true)
1148 throw (ParseException) jjte007;
1149 }
1150 }
1151 {
1152 if (true)
1153 throw (Error ) jjte007;
1154 }
1155 } finally {
1156 if (jjtc007) {
1157 jjtree.closeNodeScope(jjtn007, 2);
1158 }
1159 }
1160 break;
1161 case 34:
1162 jj_consume_token(34);
1163 ASTGENode jjtn008 = new ASTGENode(this, JJTGENODE);
1164 boolean jjtc008 = true;
1165 jjtree.openNodeScope(jjtn008);
1166 try {
1167 AdditiveExpression();
1168 } catch (Throwable jjte008) {
1169 if (jjtc008) {
1170 jjtree.clearNodeScope(jjtn008);
1171 jjtc008 = false;
1172 } else {
1173 jjtree.popNode();
1174 }
1175 if (jjte008 instanceof RuntimeException ) {
1176 {
1177 if (true)
1178 throw (RuntimeException ) jjte008;
1179 }
1180 }
1181 if (jjte008 instanceof ParseException) {
1182 {
1183 if (true)
1184 throw (ParseException) jjte008;
1185 }
1186 }
1187 {
1188 if (true)
1189 throw (Error ) jjte008;
1190 }
1191 } finally {
1192 if (jjtc008) {
1193 jjtree.closeNodeScope(jjtn008, 2);
1194 }
1195 }
1196 break;
1197 default:
1198 jj_la1[14] = jj_gen;
1199 jj_consume_token(-1);
1200 throw new ParseException();
1201 }
1202 }
1203 }
1204
1205 final public void AdditiveExpression() throws ParseException {
1206 MultiplicativeExpression();
1207 label_10: while (true) {
1208 switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1209 case 35:
1210 case 36:
1211 ;
1212 break;
1213 default:
1214 jj_la1[15] = jj_gen;
1215 break label_10;
1216 }
1217 switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1218 case 35:
1219 jj_consume_token(35);
1220 ASTAddNode jjtn001 = new ASTAddNode(this, JJTADDNODE);
1221 boolean jjtc001 = true;
1222 jjtree.openNodeScope(jjtn001);
1223 try {
1224 MultiplicativeExpression();
1225 } catch (Throwable jjte001) {
1226 if (jjtc001) {
1227 jjtree.clearNodeScope(jjtn001);
1228 jjtc001 = false;
1229 } else {
1230 jjtree.popNode();
1231 }
1232 if (jjte001 instanceof RuntimeException ) {
1233 {
1234 if (true)
1235 throw (RuntimeException ) jjte001;
1236 }
1237 }
1238 if (jjte001 instanceof ParseException) {
1239 {
1240 if (true)
1241 throw (ParseException) jjte001;
1242 }
1243 }
1244 {
1245 if (true)
1246 throw (Error ) jjte001;
1247 }
1248 } finally {
1249 if (jjtc001) {
1250 jjtree.closeNodeScope(jjtn001, 2);
1251 }
1252 }
1253 break;
1254 case 36:
1255 jj_consume_token(36);
1256 ASTSubtractNode jjtn002 = new ASTSubtractNode(this, JJTSUBTRACTNODE);
1257 boolean jjtc002 = true;
1258 jjtree.openNodeScope(jjtn002);
1259 try {
1260 MultiplicativeExpression();
1261 } catch (Throwable jjte002) {
1262 if (jjtc002) {
1263 jjtree.clearNodeScope(jjtn002);
1264 jjtc002 = false;
1265 } else {
1266 jjtree.popNode();
1267 }
1268 if (jjte002 instanceof RuntimeException ) {
1269 {
1270 if (true)
1271 throw (RuntimeException ) jjte002;
1272 }
1273 }
1274 if (jjte002 instanceof ParseException) {
1275 {
1276 if (true)
1277 throw (ParseException) jjte002;
1278 }
1279 }
1280 {
1281 if (true)
1282 throw (Error ) jjte002;
1283 }
1284 } finally {
1285 if (jjtc002) {
1286 jjtree.closeNodeScope(jjtn002, 2);
1287 }
1288 }
1289 break;
1290 default:
1291 jj_la1[16] = jj_gen;
1292 jj_consume_token(-1);
1293 throw new ParseException();
1294 }
1295 }
1296 }
1297
1298 final public void MultiplicativeExpression() throws ParseException {
1299 UnaryExpression();
1300 label_11: while (true) {
1301 switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1302 case 37:
1303 case 38:
1304 case 39:
1305 case 40:
1306 case 41:
1307 ;
1308 break;
1309 default:
1310 jj_la1[17] = jj_gen;
1311 break label_11;
1312 }
1313 switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1314 case 37:
1315 jj_consume_token(37);
1316 ASTMulNode jjtn001 = new ASTMulNode(this, JJTMULNODE);
1317 boolean jjtc001 = true;
1318 jjtree.openNodeScope(jjtn001);
1319 try {
1320 UnaryExpression();
1321 } catch (Throwable jjte001) {
1322 if (jjtc001) {
1323 jjtree.clearNodeScope(jjtn001);
1324 jjtc001 = false;
1325 } else {
1326 jjtree.popNode();
1327 }
1328 if (jjte001 instanceof RuntimeException ) {
1329 {
1330 if (true)
1331 throw (RuntimeException ) jjte001;
1332 }
1333 }
1334 if (jjte001 instanceof ParseException) {
1335 {
1336 if (true)
1337 throw (ParseException) jjte001;
1338 }
1339 }
1340 {
1341 if (true)
1342 throw (Error ) jjte001;
1343 }
1344 } finally {
1345 if (jjtc001) {
1346 jjtree.closeNodeScope(jjtn001, 2);
1347 }
1348 }
1349 break;
1350 case 38:
1351 jj_consume_token(38);
1352 ASTDivNode jjtn002 = new ASTDivNode(this, JJTDIVNODE);
1353 boolean jjtc002 = true;
1354 jjtree.openNodeScope(jjtn002);
1355 try {
1356 UnaryExpression();
1357 } catch (Throwable jjte002) {
1358 if (jjtc002) {
1359 jjtree.clearNodeScope(jjtn002);
1360 jjtc002 = false;
1361 } else {
1362 jjtree.popNode();
1363 }
1364 if (jjte002 instanceof RuntimeException ) {
1365 {
1366 if (true)
1367 throw (RuntimeException ) jjte002;
1368 }
1369 }
1370 if (jjte002 instanceof ParseException) {
1371 {
1372 if (true)
1373 throw (ParseException) jjte002;
1374 }
1375 }
1376 {
1377 if (true)
1378 throw (Error ) jjte002;
1379 }
1380 } finally {
1381 if (jjtc002) {
1382 jjtree.closeNodeScope(jjtn002, 2);
1383 }
1384 }
1385 break;
1386 case 39:
1387 jj_consume_token(39);
1388 ASTDivNode jjtn003 = new ASTDivNode(this, JJTDIVNODE);
1389 boolean jjtc003 = true;
1390 jjtree.openNodeScope(jjtn003);
1391 try {
1392 UnaryExpression();
1393 } catch (Throwable jjte003) {
1394 if (jjtc003) {
1395 jjtree.clearNodeScope(jjtn003);
1396 jjtc003 = false;
1397 } else {
1398 jjtree.popNode();
1399 }
1400 if (jjte003 instanceof RuntimeException ) {
1401 {
1402 if (true)
1403 throw (RuntimeException ) jjte003;
1404 }
1405 }
1406 if (jjte003 instanceof ParseException) {
1407 {
1408 if (true)
1409 throw (ParseException) jjte003;
1410 }
1411 }
1412 {
1413 if (true)
1414 throw (Error ) jjte003;
1415 }
1416 } finally {
1417 if (jjtc003) {
1418 jjtree.closeNodeScope(jjtn003, 2);
1419 }
1420 }
1421 break;
1422 case 40:
1423 jj_consume_token(40);
1424 ASTModNode jjtn004 = new ASTModNode(this, JJTMODNODE);
1425 boolean jjtc004 = true;
1426 jjtree.openNodeScope(jjtn004);
1427 try {
1428 UnaryExpression();
1429 } catch (Throwable jjte004) {
1430 if (jjtc004) {
1431 jjtree.clearNodeScope(jjtn004);
1432 jjtc004 = false;
1433 } else {
1434 jjtree.popNode();
1435 }
1436 if (jjte004 instanceof RuntimeException ) {
1437 {
1438 if (true)
1439 throw (RuntimeException ) jjte004;
1440 }
1441 }
1442 if (jjte004 instanceof ParseException) {
1443 {
1444 if (true)
1445 throw (ParseException) jjte004;
1446 }
1447 }
1448 {
1449 if (true)
1450 throw (Error ) jjte004;
1451 }
1452 } finally {
1453 if (jjtc004) {
1454 jjtree.closeNodeScope(jjtn004, 2);
1455 }
1456 }
1457 break;
1458 case 41:
1459 jj_consume_token(41);
1460 ASTModNode jjtn005 = new ASTModNode(this, JJTMODNODE);
1461 boolean jjtc005 = true;
1462 jjtree.openNodeScope(jjtn005);
1463 try {
1464 UnaryExpression();
1465 } catch (Throwable jjte005) {
1466 if (jjtc005) {
1467 jjtree.clearNodeScope(jjtn005);
1468 jjtc005 = false;
1469 } else {
1470 jjtree.popNode();
1471 }
1472 if (jjte005 instanceof RuntimeException ) {
1473 {
1474 if (true)
1475 throw (RuntimeException ) jjte005;
1476 }
1477 }
1478 if (jjte005 instanceof ParseException) {
1479 {
1480 if (true)
1481 throw (ParseException) jjte005;
1482 }
1483 }
1484 {
1485 if (true)
1486 throw (Error ) jjte005;
1487 }
1488 } finally {
1489 if (jjtc005) {
1490 jjtree.closeNodeScope(jjtn005, 2);
1491 }
1492 }
1493 break;
1494 default:
1495 jj_la1[18] = jj_gen;
1496 jj_consume_token(-1);
1497 throw new ParseException();
1498 }
1499 }
1500 }
1501
1502 final public void UnaryExpression() throws ParseException {
1503 switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1504 case 36:
1505 jj_consume_token(36);
1506 ASTUnaryMinusNode jjtn001 = new ASTUnaryMinusNode(this, JJTUNARYMINUSNODE);
1507 boolean jjtc001 = true;
1508 jjtree.openNodeScope(jjtn001);
1509 try {
1510 UnaryExpression();
1511 } catch (Throwable jjte001) {
1512 if (jjtc001) {
1513 jjtree.clearNodeScope(jjtn001);
1514 jjtc001 = false;
1515 } else {
1516 jjtree.popNode();
1517 }
1518 if (jjte001 instanceof RuntimeException ) {
1519 {
1520 if (true)
1521 throw (RuntimeException ) jjte001;
1522 }
1523 }
1524 if (jjte001 instanceof ParseException) {
1525 {
1526 if (true)
1527 throw (ParseException) jjte001;
1528 }
1529 }
1530 {
1531 if (true)
1532 throw (Error ) jjte001;
1533 }
1534 } finally {
1535 if (jjtc001) {
1536 jjtree.closeNodeScope(jjtn001, 1);
1537 }
1538 }
1539 break;
1540 case 42:
1541 jj_consume_token(42);
1542 ASTBitwiseComplNode jjtn002 = new ASTBitwiseComplNode(this, JJTBITWISECOMPLNODE);
1543 boolean jjtc002 = true;
1544 jjtree.openNodeScope(jjtn002);
1545 try {
1546 UnaryExpression();
1547 } catch (Throwable jjte002) {
1548 if (jjtc002) {
1549 jjtree.clearNodeScope(jjtn002);
1550 jjtc002 = false;
1551 } else {
1552 jjtree.popNode();
1553 }
1554 if (jjte002 instanceof RuntimeException ) {
1555 {
1556 if (true)
1557 throw (RuntimeException ) jjte002;
1558 }
1559 }
1560 if (jjte002 instanceof ParseException) {
1561 {
1562 if (true)
1563 throw (ParseException) jjte002;
1564 }
1565 }
1566 {
1567 if (true)
1568 throw (Error ) jjte002;
1569 }
1570 } finally {
1571 if (jjtc002) {
1572 jjtree.closeNodeScope(jjtn002, 1);
1573 }
1574 }
1575 break;
1576 case 43:
1577 jj_consume_token(43);
1578 ASTNotNode jjtn003 = new ASTNotNode(this, JJTNOTNODE);
1579 boolean jjtc003 = true;
1580 jjtree.openNodeScope(jjtn003);
1581 try {
1582 UnaryExpression();
1583 } catch (Throwable jjte003) {
1584 if (jjtc003) {
1585 jjtree.clearNodeScope(jjtn003);
1586 jjtc003 = false;
1587 } else {
1588 jjtree.popNode();
1589 }
1590 if (jjte003 instanceof RuntimeException ) {
1591 {
1592 if (true)
1593 throw (RuntimeException ) jjte003;
1594 }
1595 }
1596 if (jjte003 instanceof ParseException) {
1597 {
1598 if (true)
1599 throw (ParseException) jjte003;
1600 }
1601 }
1602 {
1603 if (true)
1604 throw (Error ) jjte003;
1605 }
1606 } finally {
1607 if (jjtc003) {
1608 jjtree.closeNodeScope(jjtn003, 1);
1609 }
1610 }
1611 break;
1612 case 44:
1613 jj_consume_token(44);
1614 ASTNotNode jjtn004 = new ASTNotNode(this, JJTNOTNODE);
1615 boolean jjtc004 = true;
1616 jjtree.openNodeScope(jjtn004);
1617 try {
1618 UnaryExpression();
1619 } catch (Throwable jjte004) {
1620 if (jjtc004) {
1621 jjtree.clearNodeScope(jjtn004);
1622 jjtc004 = false;
1623 } else {
1624 jjtree.popNode();
1625 }
1626 if (jjte004 instanceof RuntimeException ) {
1627 {
1628 if (true)
1629 throw (RuntimeException ) jjte004;
1630 }
1631 }
1632 if (jjte004 instanceof ParseException) {
1633 {
1634 if (true)
1635 throw (ParseException) jjte004;
1636 }
1637 }
1638 {
1639 if (true)
1640 throw (Error ) jjte004;
1641 }
1642 } finally {
1643 if (jjtc004) {
1644 jjtree.closeNodeScope(jjtn004, 1);
1645 }
1646 }
1647 break;
1648 case INTEGER_LITERAL:
1649 case FLOAT_LITERAL:
1650 case 11:
1651 case 12:
1652 case 14:
1653 case 45:
1654 case 46:
1655 case 47:
1656 case IDENTIFIER:
1657 case STRING_LITERAL:
1658 PrimaryExpression();
1659 break;
1660 default:
1661 jj_la1[19] = jj_gen;
1662 jj_consume_token(-1);
1663 throw new ParseException();
1664 }
1665 }
1666
1667 final public void PrimaryExpression() throws ParseException {
1668 switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1669 case INTEGER_LITERAL:
1670 case FLOAT_LITERAL:
1671 case 45:
1672 case 46:
1673 case 47:
1674 case STRING_LITERAL:
1675 Literal();
1676 break;
1677 case IDENTIFIER:
1678 Reference();
1679 break;
1680 case 12:
1681 jj_consume_token(12);
1682 Expression();
1683 jj_consume_token(13);
1684 break;
1685 case 11:
1686 EmptyFunction();
1687 break;
1688 case 14:
1689 SizeFunction();
1690 break;
1691 default:
1692 jj_la1[20] = jj_gen;
1693 jj_consume_token(-1);
1694 throw new ParseException();
1695 }
1696 }
1697
1698 final public void Literal() throws ParseException {
1699 Token t;
1700 switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1701 case INTEGER_LITERAL:
1702 IntegerLiteral();
1703 break;
1704 case FLOAT_LITERAL:
1705 FloatLiteral();
1706 break;
1707 case 46:
1708 case 47:
1709 BooleanLiteral();
1710 break;
1711 case STRING_LITERAL:
1712 StringLiteral();
1713 break;
1714 case 45:
1715 NullLiteral();
1716 break;
1717 default:
1718 jj_la1[21] = jj_gen;
1719 jj_consume_token(-1);
1720 throw new ParseException();
1721 }
1722 }
1723
1724 final public void NullLiteral() throws ParseException {
1725
1726 ASTNullLiteral jjtn000 = new ASTNullLiteral(this, JJTNULLLITERAL);
1727 boolean jjtc000 = true;
1728 jjtree.openNodeScope(jjtn000);
1729 try {
1730 jj_consume_token(45);
1731 } finally {
1732 if (jjtc000) {
1733 jjtree.closeNodeScope(jjtn000, true);
1734 }
1735 }
1736 }
1737
1738 final public void BooleanLiteral() throws ParseException {
1739 switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1740 case 46:
1741 ASTTrueNode jjtn001 = new ASTTrueNode(this, JJTTRUENODE);
1742 boolean jjtc001 = true;
1743 jjtree.openNodeScope(jjtn001);
1744 try {
1745 jj_consume_token(46);
1746 } finally {
1747 if (jjtc001) {
1748 jjtree.closeNodeScope(jjtn001, true);
1749 }
1750 }
1751 break;
1752 case 47:
1753 ASTFalseNode jjtn002 = new ASTFalseNode(this, JJTFALSENODE);
1754 boolean jjtc002 = true;
1755 jjtree.openNodeScope(jjtn002);
1756 try {
1757 jj_consume_token(47);
1758 } finally {
1759 if (jjtc002) {
1760 jjtree.closeNodeScope(jjtn002, true);
1761 }
1762 }
1763 break;
1764 default:
1765 jj_la1[22] = jj_gen;
1766 jj_consume_token(-1);
1767 throw new ParseException();
1768 }
1769 }
1770
1771 final public void IntegerLiteral() throws ParseException {
1772
1773 ASTIntegerLiteral jjtn000 = new ASTIntegerLiteral(this, JJTINTEGERLITERAL);
1774 boolean jjtc000 = true;
1775 jjtree.openNodeScope(jjtn000);
1776 Token t;
1777 try {
1778 t = jj_consume_token(INTEGER_LITERAL);
1779 jjtree.closeNodeScope(jjtn000, true);
1780 jjtc000 = false;
1781 jjtn000.val = Integer.valueOf(t.image);
1782 } finally {
1783 if (jjtc000) {
1784 jjtree.closeNodeScope(jjtn000, true);
1785 }
1786 }
1787 }
1788
1789 final public void FloatLiteral() throws ParseException {
1790
1791 ASTFloatLiteral jjtn000 = new ASTFloatLiteral(this, JJTFLOATLITERAL);
1792 boolean jjtc000 = true;
1793 jjtree.openNodeScope(jjtn000);
1794 Token t;
1795 try {
1796 t = jj_consume_token(FLOAT_LITERAL);
1797 jjtree.closeNodeScope(jjtn000, true);
1798 jjtc000 = false;
1799 jjtn000.val = Float.valueOf(t.image);
1800 } finally {
1801 if (jjtc000) {
1802 jjtree.closeNodeScope(jjtn000, true);
1803 }
1804 }
1805 }
1806
1807 final public void StringLiteral() throws ParseException {
1808
1809 ASTStringLiteral jjtn000 = new ASTStringLiteral(this, JJTSTRINGLITERAL);
1810 boolean jjtc000 = true;
1811 jjtree.openNodeScope(jjtn000);
1812 Token t;
1813 try {
1814 t = jj_consume_token(STRING_LITERAL);
1815 jjtree.closeNodeScope(jjtn000, true);
1816 jjtc000 = false;
1817 jjtn000.literal = t.image.substring(1, t.image.length() - 1);
1818 } finally {
1819 if (jjtc000) {
1820 jjtree.closeNodeScope(jjtn000, true);
1821 }
1822 }
1823 }
1824
1825
1828 final public void Statement() throws ParseException {
1829 switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1830 case 48:
1831 jj_consume_token(48);
1832 break;
1833 case 9:
1834 Block();
1835 break;
1836 default:
1837 jj_la1[23] = jj_gen;
1838 if (jj_2_2(2147483647)) {
1839 ReferenceExpression();
1840 } else if (jj_2_3(2147483647)) {
1841 StatementExpression();
1842 } else {
1843 switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1844 case INTEGER_LITERAL:
1845 case FLOAT_LITERAL:
1846 case 11:
1847 case 12:
1848 case 14:
1849 case 36:
1850 case 42:
1851 case 43:
1852 case 44:
1853 case 45:
1854 case 46:
1855 case 47:
1856 case IDENTIFIER:
1857 case STRING_LITERAL:
1858 ExpressionExpression();
1859 break;
1860 case 49:
1861 IfStatement();
1862 break;
1863 case 52:
1864 ForeachStatement();
1865 break;
1866 case 51:
1867 WhileStatement();
1868 break;
1869 default:
1870 jj_la1[24] = jj_gen;
1871 jj_consume_token(-1);
1872 throw new ParseException();
1873 }
1874 }
1875 }
1876 }
1877
1878 final public void ExpressionExpression() throws ParseException {
1879
1880 ASTExpressionExpression jjtn000 = new ASTExpressionExpression(this, JJTEXPRESSIONEXPRESSION);
1881 boolean jjtc000 = true;
1882 jjtree.openNodeScope(jjtn000);
1883 try {
1884 Expression();
1885 jj_consume_token(48);
1886 } catch (Throwable jjte000) {
1887 if (jjtc000) {
1888 jjtree.clearNodeScope(jjtn000);
1889 jjtc000 = false;
1890 } else {
1891 jjtree.popNode();
1892 }
1893 if (jjte000 instanceof RuntimeException ) {
1894 {
1895 if (true)
1896 throw (RuntimeException ) jjte000;
1897 }
1898 }
1899 if (jjte000 instanceof ParseException) {
1900 {
1901 if (true)
1902 throw (ParseException) jjte000;
1903 }
1904 }
1905 {
1906 if (true)
1907 throw (Error ) jjte000;
1908 }
1909 } finally {
1910 if (jjtc000) {
1911 jjtree.closeNodeScope(jjtn000, true);
1912 }
1913 }
1914 }
1915
1916 final public void StatementExpression() throws ParseException {
1917
1918 ASTStatementExpression jjtn000 = new ASTStatementExpression(this, JJTSTATEMENTEXPRESSION);
1919 boolean jjtc000 = true;
1920 jjtree.openNodeScope(jjtn000);
1921 try {
1922 Assignment();
1923 jj_consume_token(48);
1924 } catch (Throwable jjte000) {
1925 if (jjtc000) {
1926 jjtree.clearNodeScope(jjtn000);
1927 jjtc000 = false;
1928 } else {
1929 jjtree.popNode();
1930 }
1931 if (jjte000 instanceof RuntimeException ) {
1932 {
1933 if (true)
1934 throw (RuntimeException ) jjte000;
1935 }
1936 }
1937 if (jjte000 instanceof ParseException) {
1938 {
1939 if (true)
1940 throw (ParseException) jjte000;
1941 }
1942 }
1943 {
1944 if (true)
1945 throw (Error ) jjte000;
1946 }
1947 } finally {
1948 if (jjtc000) {
1949 jjtree.closeNodeScope(jjtn000, true);
1950 }
1951 }
1952 }
1953
1954 final public void ReferenceExpression() throws ParseException {
1955
1956 ASTReferenceExpression jjtn000 = new ASTReferenceExpression(this, JJTREFERENCEEXPRESSION);
1957 boolean jjtc000 = true;
1958 jjtree.openNodeScope(jjtn000);
1959 try {
1960 Reference();
1961 jj_consume_token(48);
1962 } catch (Throwable jjte000) {
1963 if (jjtc000) {
1964 jjtree.clearNodeScope(jjtn000);
1965 jjtc000 = false;
1966 } else {
1967 jjtree.popNode();
1968 }
1969 if (jjte000 instanceof RuntimeException ) {
1970 {
1971 if (true)
1972 throw (RuntimeException ) jjte000;
1973 }
1974 }
1975 if (jjte000 instanceof ParseException) {
1976 {
1977 if (true)
1978 throw (ParseException) jjte000;
1979 }
1980 }
1981 {
1982 if (true)
1983 throw (Error ) jjte000;
1984 }
1985 } finally {
1986 if (jjtc000) {
1987 jjtree.closeNodeScope(jjtn000, true);
1988 }
1989 }
1990 }
1991
1992 final public void IfStatement() throws ParseException {
1993
1994 ASTIfStatement jjtn000 = new ASTIfStatement(this, JJTIFSTATEMENT);
1995 boolean jjtc000 = true;
1996 jjtree.openNodeScope(jjtn000);
1997 try {
1998 jj_consume_token(49);
1999 jj_consume_token(12);
2000 Expression();
2001 jj_consume_token(13);
2002 Statement();
2003 switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2004 case 50:
2005 jj_consume_token(50);
2006 Statement();
2007 break;
2008 default:
2009 jj_la1[25] = jj_gen;
2010 ;
2011 }
2012 } catch (Throwable jjte000) {
2013 if (jjtc000) {
2014 jjtree.clearNodeScope(jjtn000);
2015 jjtc000 = false;
2016 } else {
2017 jjtree.popNode();
2018 }
2019 if (jjte000 instanceof RuntimeException ) {
2020 {
2021 if (true)
2022 throw (RuntimeException ) jjte000;
2023 }
2024 }
2025 if (jjte000 instanceof ParseException) {
2026 {
2027 if (true)
2028 throw (ParseException) jjte000;
2029 }
2030 }
2031 {
2032 if (true)
2033 throw (Error ) jjte000;
2034 }
2035 } finally {
2036 if (jjtc000) {
2037 jjtree.closeNodeScope(jjtn000, true);
2038 }
2039 }
2040 }
2041
2042 final public void WhileStatement() throws ParseException {
2043
2044 ASTWhileStatement jjtn000 = new ASTWhileStatement(this, JJTWHILESTATEMENT);
2045 boolean jjtc000 = true;
2046 jjtree.openNodeScope(jjtn000);
2047 try {
2048 jj_consume_token(51);
2049 jj_consume_token(12);
2050 Expression();
2051 jj_consume_token(13);
2052 Statement();
2053 } catch (Throwable jjte000) {
2054 if (jjtc000) {
2055 jjtree.clearNodeScope(jjtn000);
2056 jjtc000 = false;
2057 } else {
2058 jjtree.popNode();
2059 }
2060 if (jjte000 instanceof RuntimeException ) {
2061 {
2062 if (true)
2063 throw (RuntimeException ) jjte000;
2064 }
2065 }
2066 if (jjte000 instanceof ParseException) {
2067 {
2068 if (true)
2069 throw (ParseException) jjte000;
2070 }
2071 }
2072 {
2073 if (true)
2074 throw (Error ) jjte000;
2075 }
2076 } finally {
2077 if (jjtc000) {
2078 jjtree.closeNodeScope(jjtn000, true);
2079 }
2080 }
2081 }
2082
2083 final public void ForeachStatement() throws ParseException {
2084
2085 ASTForeachStatement jjtn000 = new ASTForeachStatement(this, JJTFOREACHSTATEMENT);
2086 boolean jjtc000 = true;
2087 jjtree.openNodeScope(jjtn000);
2088 try {
2089 jj_consume_token(52);
2090 jj_consume_token(12);
2091 Reference();
2092 jj_consume_token(53);
2093 Reference();
2094 jj_consume_token(13);
2095 Statement();
2096 } catch (Throwable jjte000) {
2097 if (jjtc000) {
2098 jjtree.clearNodeScope(jjtn000);
2099 jjtc000 = false;
2100 } else {
2101 jjtree.popNode();
2102 }
2103 if (jjte000 instanceof RuntimeException ) {
2104 {
2105 if (true)
2106 throw (RuntimeException ) jjte000;
2107 }
2108 }
2109 if (jjte000 instanceof ParseException) {
2110 {
2111 if (true)
2112 throw (ParseException) jjte000;
2113 }
2114 }
2115 {
2116 if (true)
2117 throw (Error ) jjte000;
2118 }
2119 } finally {
2120 if (jjtc000) {
2121 jjtree.closeNodeScope(jjtn000, true);
2122 }
2123 }
2124 }
2125
2126 final public void Method() throws ParseException {
2127
2128 ASTMethod jjtn000 = new ASTMethod(this, JJTMETHOD);
2129 boolean jjtc000 = true;
2130 jjtree.openNodeScope(jjtn000);
2131 try {
2132 Identifier();
2133 jj_consume_token(12);
2134 switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2135 case INTEGER_LITERAL:
2136 case FLOAT_LITERAL:
2137 case 11:
2138 case 12:
2139 case 14:
2140 case 36:
2141 case 42:
2142 case 43:
2143 case 44:
2144 case 45:
2145 case 46:
2146 case 47:
2147 case IDENTIFIER:
2148 case STRING_LITERAL:
2149 Parameter();
2150 label_12: while (true) {
2151 switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2152 case 54:
2153 ;
2154 break;
2155 default:
2156 jj_la1[26] = jj_gen;
2157 break label_12;
2158 }
2159 jj_consume_token(54);
2160 Parameter();
2161 }
2162 break;
2163 default:
2164 jj_la1[27] = jj_gen;
2165 ;
2166 }
2167 jj_consume_token(13);
2168 } catch (Throwable jjte000) {
2169 if (jjtc000) {
2170 jjtree.clearNodeScope(jjtn000);
2171 jjtc000 = false;
2172 } else {
2173 jjtree.popNode();
2174 }
2175 if (jjte000 instanceof RuntimeException ) {
2176 {
2177 if (true)
2178 throw (RuntimeException ) jjte000;
2179 }
2180 }
2181 if (jjte000 instanceof ParseException) {
2182 {
2183 if (true)
2184 throw (ParseException) jjte000;
2185 }
2186 }
2187 {
2188 if (true)
2189 throw (Error ) jjte000;
2190 }
2191 } finally {
2192 if (jjtc000) {
2193 jjtree.closeNodeScope(jjtn000, true);
2194 }
2195 }
2196 }
2197
2198 final public void ArrayAccess() throws ParseException {
2199
2200 ASTArrayAccess jjtn000 = new ASTArrayAccess(this, JJTARRAYACCESS);
2201 boolean jjtc000 = true;
2202 jjtree.openNodeScope(jjtn000);
2203 try {
2204 Identifier();
2205 label_13: while (true) {
2206 jj_consume_token(55);
2207 if (jj_2_4(3)) {
2208 Expression();
2209 } else {
2210 switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2211 case INTEGER_LITERAL:
2212 IntegerLiteral();
2213 break;
2214 case IDENTIFIER:
2215 Reference();
2216 break;
2217 default:
2218 jj_la1[28] = jj_gen;
2219 jj_consume_token(-1);
2220 throw new ParseException();
2221 }
2222 }
2223 jj_consume_token(56);
2224 switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2225 case 55:
2226 ;
2227 break;
2228 default:
2229 jj_la1[29] = jj_gen;
2230 break label_13;
2231 }
2232 }
2233 } catch (Throwable jjte000) {
2234 if (jjtc000) {
2235 jjtree.clearNodeScope(jjtn000);
2236 jjtc000 = false;
2237 } else {
2238 jjtree.popNode();
2239 }
2240 if (jjte000 instanceof RuntimeException ) {
2241 {
2242 if (true)
2243 throw (RuntimeException ) jjte000;
2244 }
2245 }
2246 if (jjte000 instanceof ParseException) {
2247 {
2248 if (true)
2249 throw (ParseException) jjte000;
2250 }
2251 }
2252 {
2253 if (true)
2254 throw (Error ) jjte000;
2255 }
2256 } finally {
2257 if (jjtc000) {
2258 jjtree.closeNodeScope(jjtn000, true);
2259 }
2260 }
2261 }
2262
2263 final public void SizeMethod() throws ParseException {
2264
2265 ASTSizeMethod jjtn000 = new ASTSizeMethod(this, JJTSIZEMETHOD);
2266 boolean jjtc000 = true;
2267 jjtree.openNodeScope(jjtn000);
2268 try {
2269 jj_consume_token(14);
2270 jj_consume_token(12);
2271 jj_consume_token(13);
2272 } finally {
2273 if (jjtc000) {
2274 jjtree.closeNodeScope(jjtn000, true);
2275 }
2276 }
2277 }
2278
2279 final public void Reference() throws ParseException {
2280
2281 ASTReference jjtn000 = new ASTReference(this, JJTREFERENCE);
2282 boolean jjtc000 = true;
2283 jjtree.openNodeScope(jjtn000);
2284 try {
2285 if (jj_2_5(2147483647)) {
2286 ArrayAccess();
2287 } else {
2288 switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2289 case IDENTIFIER:
2290 Identifier();
2291 break;
2292 default:
2293 jj_la1[30] = jj_gen;
2294 jj_consume_token(-1);
2295 throw new ParseException();
2296 }
2297 }
2298 label_14: while (true) {
2299 if (jj_2_6(2)) {
2300 ;
2301 } else {
2302 break label_14;
2303 }
2304 jj_consume_token(57);
2305 if (jj_2_8(2147483647)) {
2306 ArrayAccess();
2307 } else {
2308 switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2309 case INTEGER_LITERAL:
2310 case 14:
2311 case IDENTIFIER:
2312 if (jj_2_7(3)) {
2313 Method();
2314 } else {
2315 switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2316 case 14:
2317 SizeMethod();
2318 break;
2319 case IDENTIFIER:
2320 Identifier();
2321 break;
2322 case INTEGER_LITERAL:
2323 IntegerLiteral();
2324 break;
2325 default:
2326 jj_la1[31] = jj_gen;
2327 jj_consume_token(-1);
2328 throw new ParseException();
2329 }
2330 }
2331 break;
2332 default:
2333 jj_la1[32] = jj_gen;
2334 jj_consume_token(-1);
2335 throw new ParseException();
2336 }
2337 }
2338 }
2339 } catch (Throwable jjte000) {
2340 if (jjtc000) {
2341 jjtree.clearNodeScope(jjtn000);
2342 jjtc000 = false;
2343 } else {
2344 jjtree.popNode();
2345 }
2346 if (jjte000 instanceof RuntimeException ) {
2347 {
2348 if (true)
2349 throw (RuntimeException ) jjte000;
2350 }
2351 }
2352 if (jjte000 instanceof ParseException) {
2353 {
2354 if (true)
2355 throw (ParseException) jjte000;
2356 }
2357 }
2358 {
2359 if (true)
2360 throw (Error ) jjte000;
2361 }
2362 } finally {
2363 if (jjtc000) {
2364 jjtree.closeNodeScope(jjtn000, true);
2365 }
2366 }
2367 }
2368
2369 final public void Parameter() throws ParseException {
2370 if (jj_2_9(3)) {
2371 Expression();
2372 } else {
2373 switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2374 case INTEGER_LITERAL:
2375 case FLOAT_LITERAL:
2376 case 45:
2377 case 46:
2378 case 47:
2379 case STRING_LITERAL:
2380 Literal();
2381 break;
2382 case IDENTIFIER:
2383 Reference();
2384 break;
2385 default:
2386 jj_la1[33] = jj_gen;
2387 jj_consume_token(-1);
2388 throw new ParseException();
2389 }
2390 }
2391 }
2392
2393 final private boolean jj_2_1(int xla) {
2394 jj_la = xla;
2395 jj_lastpos = jj_scanpos = token;
2396 boolean retval = !jj_3_1();
2397 jj_save(0, xla);
2398 return retval;
2399 }
2400
2401 final private boolean jj_2_2(int xla) {
2402 jj_la = xla;
2403 jj_lastpos = jj_scanpos = token;
2404 boolean retval = !jj_3_2();
2405 jj_save(1, xla);
2406 return retval;
2407 }
2408
2409 final private boolean jj_2_3(int xla) {
2410 jj_la = xla;
2411 jj_lastpos = jj_scanpos = token;
2412 boolean retval = !jj_3_3();
2413 jj_save(2, xla);
2414 return retval;
2415 }
2416
2417 final private boolean jj_2_4(int xla) {
2418 jj_la = xla;
2419 jj_lastpos = jj_scanpos = token;
2420 boolean retval = !jj_3_4();
2421 jj_save(3, xla);
2422 return retval;
2423 }
2424
2425 final private boolean jj_2_5(int xla) {
2426 jj_la = xla;
2427 jj_lastpos = jj_scanpos = token;
2428 boolean retval = !jj_3_5();
2429 jj_save(4, xla);
2430 return retval;
2431 }
2432
2433 final private boolean jj_2_6(int xla) {
2434 jj_la = xla;
2435 jj_lastpos = jj_scanpos = token;
2436 boolean retval = !jj_3_6();
2437 jj_save(5, xla);
2438 return retval;
2439 }
2440
2441 final private boolean jj_2_7(int xla) {
2442 jj_la = xla;
2443 jj_lastpos = jj_scanpos = token;
2444 boolean retval = !jj_3_7();
2445 jj_save(6, xla);
2446 return retval;
2447 }
2448
2449 final private boolean jj_2_8(int xla) {
2450 jj_la = xla;
2451 jj_lastpos = jj_scanpos = token;
2452 boolean retval = !jj_3_8();
2453 jj_save(7, xla);
2454 return retval;
2455 }
2456
2457 final private boolean jj_2_9(int xla) {
2458 jj_la = xla;
2459 jj_lastpos = jj_scanpos = token;
2460 boolean retval = !jj_3_9();
2461 jj_save(8, xla);
2462 return retval;
2463 }
2464
2465 final private boolean jj_3R_71() {
2466 if (jj_scan_token(17))
2467 return true;
2468 if (jj_la == 0 && jj_scanpos == jj_lastpos)
2469 return false;
2470 if (jj_3R_58())
2471 return true;
2472 if (jj_la == 0 && jj_scanpos == jj_lastpos)
2473 return false;
2474 return false;
2475 }
2476
2477 final private boolean jj_3R_59() {
2478 Token xsp;
2479 xsp = jj_scanpos;
2480 if (jj_3R_70()) {
2481 jj_scanpos = xsp;
2482 if (jj_3R_71())
2483 return true;
2484 if (jj_la == 0 && jj_scanpos == jj_lastpos)
2485 return false;
2486 } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
2487 return false;
2488 return false;
2489 }
2490
2491 final private boolean jj_3R_70() {
2492 if (jj_scan_token(16))
2493 return true;
2494 if (jj_la == 0 && jj_scanpos == jj_lastpos)
2495 return false;
2496 if (jj_3R_58())
2497 return true;
2498 if (jj_la == 0 && jj_scanpos == jj_lastpos)
2499 return false;
2500 return false;
2501 }
2502
2503 final private boolean jj_3R_64() {
2504 if (jj_scan_token(STRING_LITERAL))
2505 return true;
2506 if (jj_la == 0 && jj_scanpos == jj_lastpos)
2507 return false;
2508 return false;
2509 }
2510
2511 final private boolean jj_3R_47() {
2512 if (jj_3R_58())
2513 return true;
2514 if (jj_la == 0 && jj_scanpos == jj_lastpos)
2515 return false;
2516 Token xsp;
2517 while (true) {
2518 xsp = jj_scanpos;
2519 if (jj_3R_59()) {
2520 jj_scanpos = xsp;
2521 break;
2522 }
2523 if (jj_la == 0 && jj_scanpos == jj_lastpos)
2524 return false;
2525 }
2526 return false;
2527 }
2528
2529 final private boolean jj_3_1() {
2530 if (jj_3R_15())
2531 return true;
2532 if (jj_la == 0 && jj_scanpos == jj_lastpos)
2533 return false;
2534 if (jj_scan_token(15))
2535 return true;
2536 if (jj_la == 0 && jj_scanpos == jj_lastpos)
2537 return false;
2538 return false;
2539 }
2540
2541 final private boolean jj_3R_46() {
2542 if (jj_3R_15())
2543 return true;
2544 if (jj_la == 0 && jj_scanpos == jj_lastpos)
2545 return false;
2546 if (jj_scan_token(15))
2547 return true;
2548 if (jj_la == 0 && jj_scanpos == jj_lastpos)
2549 return false;
2550 if (jj_3R_17())
2551 return true;
2552 if (jj_la == 0 && jj_scanpos == jj_lastpos)
2553 return false;
2554 return false;
2555 }
2556
2557 final private boolean jj_3R_34() {
2558 if (jj_3R_18())
2559 return true;
2560 if (jj_la == 0 && jj_scanpos == jj_lastpos)
2561 return false;
2562 return false;
2563 }
2564
2565 final private boolean jj_3R_62() {
2566 if (jj_scan_token(FLOAT_LITERAL))
2567 return true;
2568 if (jj_la == 0 && jj_scanpos == jj_lastpos)
2569 return false;
2570 return false;
2571 }
2572
2573 final private boolean jj_3R_36() {
2574 if (jj_3R_47())
2575 return true;
2576 if (jj_la == 0 && jj_scanpos == jj_lastpos)
2577 return false;
2578 return false;
2579 }
2580
2581 final private boolean jj_3R_35() {
2582 if (jj_3R_46())
2583 return true;
2584 if (jj_la == 0 && jj_scanpos == jj_lastpos)
2585 return false;
2586 return false;
2587 }
2588
2589 final private boolean jj_3R_17() {
2590 Token xsp;
2591 xsp = jj_scanpos;
2592 if (jj_3R_35()) {
2593 jj_scanpos = xsp;
2594 if (jj_3R_36())
2595 return true;
2596 if (jj_la == 0 && jj_scanpos == jj_lastpos)
2597 return false;
2598 } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
2599 return false;
2600 return false;
2601 }
2602
2603 final private boolean jj_3R_56() {
2604 if (jj_scan_token(12))
2605 return true;
2606 if (jj_la == 0 && jj_scanpos == jj_lastpos)
2607 return false;
2608 if (jj_3R_16())
2609 return true;
2610 if (jj_la == 0 && jj_scanpos == jj_lastpos)
2611 return false;
2612 if (jj_scan_token(13))
2613 return true;
2614 if (jj_la == 0 && jj_scanpos == jj_lastpos)
2615 return false;
2616 return false;
2617 }
2618
2619 final private boolean jj_3R_37() {
2620 if (jj_scan_token(INTEGER_LITERAL))
2621 return true;
2622 if (jj_la == 0 && jj_scanpos == jj_lastpos)
2623 return false;
2624 return false;
2625 }
2626
2627 final private boolean jj_3R_18() {
2628 if (jj_scan_token(IDENTIFIER))
2629 return true;
2630 if (jj_la == 0 && jj_scanpos == jj_lastpos)
2631 return false;
2632 return false;
2633 }
2634
2635 final private boolean jj_3R_73() {
2636 if (jj_scan_token(47))
2637 return true;
2638 if (jj_la == 0 && jj_scanpos == jj_lastpos)
2639 return false;
2640 return false;
2641 }
2642
2643 final private boolean jj_3R_63() {
2644 Token xsp;
2645 xsp = jj_scanpos;
2646 if (jj_3R_72()) {
2647 jj_scanpos = xsp;
2648 if (jj_3R_73())
2649 return true;
2650 if (jj_la == 0 && jj_scanpos == jj_lastpos)
2651 return false;
2652 } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
2653 return false;
2654 return false;
2655 }
2656
2657 final private boolean jj_3R_72() {
2658 if (jj_scan_token(46))
2659 return true;
2660 if (jj_la == 0 && jj_scanpos == jj_lastpos)
2661 return false;
2662 return false;
2663 }
2664
2665 final private boolean jj_3R_45() {
2666 if (jj_scan_token(14))
2667 return true;
2668 if (jj_la == 0 && jj_scanpos == jj_lastpos)
2669 return false;
2670 if (jj_scan_token(12))
2671 return true;
2672 if (jj_la == 0 && jj_scanpos == jj_lastpos)
2673 return false;
2674 if (jj_3R_16())
2675 return true;
2676 if (jj_la == 0 && jj_scanpos == jj_lastpos)
2677 return false;
2678 if (jj_scan_token(13))
2679 return true;
2680 if (jj_la == 0 && jj_scanpos == jj_lastpos)
2681 return false;
2682 return false;
2683 }
2684
2685 final private boolean jj_3R_27() {
2686 if (jj_3R_16())
2687 return true;
2688 if (jj_la == 0 && jj_scanpos == jj_lastpos)
2689 return false;
2690 return false;
2691 }
2692
2693 final private boolean jj_3R_65() {
2694 if (jj_scan_token(45))
2695 return true;
2696 if (jj_la == 0 && jj_scanpos == jj_lastpos)
2697 return false;
2698 return false;
2699 }
2700
2701 final private boolean jj_3R_55() {
2702 if (jj_3R_16())
2703 return true;
2704 if (jj_la == 0 && jj_scanpos == jj_lastpos)
2705 return false;
2706 return false;
2707 }
2708
2709 final private boolean jj_3R_41() {
2710 if (jj_3R_37())
2711 return true;
2712 if (jj_la == 0 && jj_scanpos == jj_lastpos)
2713 return false;
2714 return false;
2715 }
2716
2717 final private boolean jj_3R_44() {
2718 if (jj_scan_token(11))
2719 return true;
2720 if (jj_la == 0 && jj_scanpos == jj_lastpos)
2721 return false;
2722 Token xsp;
2723 xsp = jj_scanpos;
2724 if (jj_3R_55()) {
2725 jj_scanpos = xsp;
2726 if (jj_3R_56())
2727 return true;
2728 if (jj_la == 0 && jj_scanpos == jj_lastpos)
2729 return false;
2730 } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
2731 return false;
2732 return false;
2733 }
2734
2735 final private boolean jj_3R_21() {
2736 if (jj_3R_16())
2737 return true;
2738 if (jj_la == 0 && jj_scanpos == jj_lastpos)
2739 return false;
2740 return false;
2741 }
2742
2743 final private boolean jj_3R_54() {
2744 if (jj_3R_65())
2745 return true;
2746 if (jj_la == 0 && jj_scanpos == jj_lastpos)
2747 return false;
2748 return false;
2749 }
2750
2751 final private boolean jj_3R_53() {
2752 if (jj_3R_64())
2753 return true;
2754 if (jj_la == 0 && jj_scanpos == jj_lastpos)
2755 return false;
2756 return false;
2757 }
2758
2759 final private boolean jj_3R_67() {
2760 if (jj_3R_16())
2761 return true;
2762 if (jj_la == 0 && jj_scanpos == jj_lastpos)
2763 return false;
2764 return false;
2765 }
2766
2767 final private boolean jj_3R_52() {
2768 if (jj_3R_63())
2769 return true;
2770 if (jj_la == 0 && jj_scanpos == jj_lastpos)
2771 return false;
2772 return false;
2773 }
2774
2775 final private boolean jj_3R_61() {
2776 if (jj_3R_16())
2777 return true;
2778 if (jj_la == 0 && jj_scanpos == jj_lastpos)
2779 return false;
2780 return false;
2781 }
2782
2783 final private boolean jj_3R_51() {
2784 if (jj_3R_62())
2785 return true;
2786 if (jj_la == 0 && jj_scanpos == jj_lastpos)
2787 return false;
2788 return false;
2789 }
2790
2791 final private boolean jj_3R_43() {
2792 Token xsp;
2793 xsp = jj_scanpos;
2794 if (jj_3R_50()) {
2795 jj_scanpos = xsp;
2796 if (jj_3R_51()) {
2797 jj_scanpos = xsp;
2798 if (jj_3R_52()) {
2799 jj_scanpos = xsp;
2800 if (jj_3R_53()) {
2801 jj_scanpos = xsp;
2802 if (jj_3R_54())
2803 return true;
2804 if (jj_la == 0 && jj_scanpos == jj_lastpos)
2805 return false;
2806 } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
2807 return false;
2808 } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
2809 return false;
2810 } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
2811 return false;
2812 } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
2813 return false;
2814 return false;
2815 }
2816
2817 final private boolean jj_3R_50() {
2818 if (jj_3R_37())
2819 return true;
2820 if (jj_la == 0 && jj_scanpos == jj_lastpos)
2821 return false;
2822 return false;
2823 }
2824
2825 final private boolean jj_3R_26() {
2826 if (jj_3R_37())
2827 return true;
2828 if (jj_la == 0 && jj_scanpos == jj_lastpos)
2829 return false;
2830 return false;
2831 }
2832
2833 final private boolean jj_3R_40() {
2834 if (jj_3R_18())
2835 return true;
2836 if (jj_la == 0 && jj_scanpos == jj_lastpos)
2837 return false;
2838 return false;
2839 }
2840
2841 final private boolean jj_3R_20() {
2842 if (jj_3R_37())
2843 return true;
2844 if (jj_la == 0 && jj_scanpos == jj_lastpos)
2845 return false;
2846 return false;
2847 }
2848
2849 final private boolean jj_3R_32() {
2850 if (jj_3R_45())
2851 return true;
2852 if (jj_la == 0 && jj_scanpos == jj_lastpos)
2853 return false;
2854 return false;
2855 }
2856
2857 final private boolean jj_3R_60() {
2858 if (jj_3R_43())
2859 return true;
2860 if (jj_la == 0 && jj_scanpos == jj_lastpos)
2861 return false;
2862 return false;
2863 }
2864
2865 final private boolean jj_3R_31() {
2866 if (jj_3R_44())
2867 return true;
2868 if (jj_la == 0 && jj_scanpos == jj_lastpos)
2869 return false;
2870 return false;
2871 }
2872
2873 final private boolean jj_3R_30() {
2874 if (jj_scan_token(12))
2875 return true;
2876 if (jj_la == 0 && jj_scanpos == jj_lastpos)
2877 return false;
2878 if (jj_3R_17())
2879 return true;
2880 if (jj_la == 0 && jj_scanpos == jj_lastpos)
2881 return false;
2882 if (jj_scan_token(13))
2883 return true;
2884 if (jj_la == 0 && jj_scanpos == jj_lastpos)
2885 return false;
2886 return false;
2887 }
2888
2889 final private boolean jj_3R_66() {
2890 if (jj_3R_37())
2891 return true;
2892 if (jj_la == 0 && jj_scanpos == jj_lastpos)
2893 return false;
2894 return false;
2895 }
2896
2897 final private boolean jj_3R_29() {
2898 if (jj_3R_16())
2899 return true;
2900 if (jj_la == 0 && jj_scanpos == jj_lastpos)
2901 return false;
2902 return false;
2903 }
2904
2905 final private boolean jj_3R_28() {
2906 if (jj_3R_43())
2907 return true;
2908 if (jj_la == 0 && jj_scanpos == jj_lastpos)
2909 return false;
2910 return false;
2911 }
2912
2913 final private boolean jj_3R_15() {
2914 Token xsp;
2915 xsp = jj_scanpos;
2916 if (jj_3R_28()) {
2917 jj_scanpos = xsp;
2918 if (jj_3R_29()) {
2919 jj_scanpos = xsp;
2920 if (jj_3R_30()) {
2921 jj_scanpos = xsp;
2922 if (jj_3R_31()) {
2923 jj_scanpos = xsp;
2924 if (jj_3R_32())
2925 return true;
2926 if (jj_la == 0 && jj_scanpos == jj_lastpos)
2927 return false;
2928 } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
2929 return false;
2930 } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
2931 return false;
2932 } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
2933 return false;
2934 } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
2935 return false;
2936 return false;
2937 }
2938
2939 final private boolean jj_3R_25() {
2940 if (jj_3R_17())
2941 return true;
2942 if (jj_la == 0 && jj_scanpos == jj_lastpos)
2943 return false;
2944 return false;
2945 }
2946
2947 final private boolean jj_3R_39() {
2948 if (jj_3R_48())
2949 return true;
2950 if (jj_la == 0 && jj_scanpos == jj_lastpos)
2951 return false;
2952 return false;
2953 }
2954
2955 final private boolean jj_3R_109() {
2956 if (jj_3R_15())
2957 return true;
2958 if (jj_la == 0 && jj_scanpos == jj_lastpos)
2959 return false;
2960 return false;
2961 }
2962
2963 final private boolean jj_3R_19() {
2964 if (jj_3R_17())
2965 return true;
2966 if (jj_la == 0 && jj_scanpos == jj_lastpos)
2967 return false;
2968 return false;
2969 }
2970
2971 final private boolean jj_3R_108() {
2972 if (jj_scan_token(44))
2973 return true;
2974 if (jj_la == 0 && jj_scanpos == jj_lastpos)
2975 return false;
2976 if (jj_3R_101())
2977 return true;
2978 if (jj_la == 0 && jj_scanpos == jj_lastpos)
2979 return false;
2980 return false;
2981 }
2982
2983 final private boolean jj_3R_107() {
2984 if (jj_scan_token(43))
2985 return true;
2986 if (jj_la == 0 && jj_scanpos == jj_lastpos)
2987 return false;
2988 if (jj_3R_101())
2989 return true;
2990 if (jj_la == 0 && jj_scanpos == jj_lastpos)
2991 return false;
2992 return false;
2993 }
2994
2995 final private boolean jj_3R_106() {
2996 if (jj_scan_token(42))
2997 return true;
2998 if (jj_la == 0 && jj_scanpos == jj_lastpos)
2999 return false;
3000 if (jj_3R_101())
3001 return true;
3002 if (jj_la == 0 && jj_scanpos == jj_lastpos)
3003 return false;
3004 return false;
3005 }
3006
3007 final private boolean jj_3R_105() {
3008 if (jj_scan_token(36))
3009 return true;
3010 if (jj_la == 0 && jj_scanpos == jj_lastpos)
3011 return false;
3012 if (jj_3R_101())
3013 return true;
3014 if (jj_la == 0 && jj_scanpos == jj_lastpos)
3015 return false;
3016 return false;
3017 }
3018
3019 final private boolean jj_3R_101() {
3020 Token xsp;
3021 xsp = jj_scanpos;
3022 if (jj_3R_105()) {
3023 jj_scanpos = xsp;
3024 if (jj_3R_106()) {
3025 jj_scanpos = xsp;
3026 if (jj_3R_107()) {
3027 jj_scanpos = xsp;
3028 if (jj_3R_108()) {
3029 jj_scanpos = xsp;
3030 if (jj_3R_109())
3031 return true;
3032 if (jj_la == 0 && jj_scanpos == jj_lastpos)
3033 return false;
3034 } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
3035 return false;
3036 } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
3037 return false;
3038 } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
3039 return false;
3040 } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
3041 return false;
3042 return false;
3043 }
3044
3045 final private boolean jj_3R_78() {
3046 if (jj_scan_token(54))
3047 return true;
3048 if (jj_la == 0 && jj_scanpos == jj_lastpos)
3049 return false;
3050 if (jj_3R_49())
3051 return true;
3052 if (jj_la == 0 && jj_scanpos == jj_lastpos)
3053 return false;
3054 return false;
3055 }
3056
3057 final private boolean jj_3R_114() {
3058 if (jj_scan_token(41))
3059 return true;
3060 if (jj_la == 0 && jj_scanpos == jj_lastpos)
3061 return false;
3062 if (jj_3R_101())
3063 return true;
3064 if (jj_la == 0 && jj_scanpos == jj_lastpos)
3065 return false;
3066 return false;
3067 }
3068
3069 final private boolean jj_3_8() {
3070 if (jj_3R_18())
3071 return true;
3072 if (jj_la == 0 && jj_scanpos == jj_lastpos)
3073 return false;
3074 if (jj_scan_token(55))
3075 return true;
3076 if (jj_la == 0 && jj_scanpos == jj_lastpos)
3077 return false;
3078 Token xsp;
3079 xsp = jj_scanpos;
3080 if (jj_3R_25()) {
3081 jj_scanpos = xsp;
3082 if (jj_3R_26()) {
3083 jj_scanpos = xsp;
3084 if (jj_3R_27())
3085 return true;
3086 if (jj_la == 0 && jj_scanpos == jj_lastpos)
3087 return false;
3088 } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
3089 return false;
3090 } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
3091 return false;
3092 if (jj_scan_token(56))
3093 return true;
3094 if (jj_la == 0 && jj_scanpos == jj_lastpos)
3095 return false;
3096 return false;
3097 }
3098
3099 final private boolean jj_3R_113() {
3100 if (jj_scan_token(40))
3101 return true;
3102 if (jj_la == 0 && jj_scanpos == jj_lastpos)
3103 return false;
3104 if (jj_3R_101())
3105 return true;
3106 if (jj_la == 0 && jj_scanpos == jj_lastpos)
3107 return false;
3108 return false;
3109 }
3110
3111 final private boolean jj_3_9() {
3112 if (jj_3R_17())
3113 return true;
3114 if (jj_la == 0 && jj_scanpos == jj_lastpos)
3115 return false;
3116 return false;
3117 }
3118
3119 final private boolean jj_3R_49() {
3120 Token xsp;
3121 xsp = jj_scanpos;
3122 if (jj_3_9()) {
3123 jj_scanpos = xsp;
3124 if (jj_3R_60()) {
3125 jj_scanpos = xsp;
3126 if (jj_3R_61())
3127 return true;
3128 if (jj_la == 0 && jj_scanpos == jj_lastpos)
3129 return false;
3130 } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
3131 return false;
3132 } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
3133 return false;
3134 return false;
3135 }
3136
3137 final private boolean jj_3R_112() {
3138 if (jj_scan_token(39))
3139 return true;
3140 if (jj_la == 0 && jj_scanpos == jj_lastpos)
3141 return false;
3142 if (jj_3R_101())
3143 return true;
3144 if (jj_la == 0 && jj_scanpos == jj_lastpos)
3145 return false;
3146 return false;
3147 }
3148
3149 final private boolean jj_3_4() {
3150 if (jj_3R_17())
3151 return true;
3152 if (jj_la == 0 && jj_scanpos == jj_lastpos)
3153 return false;
3154 return false;
3155 }
3156
3157 final private boolean jj_3R_111() {
3158 if (jj_scan_token(38))
3159 return true;
3160 if (jj_la == 0 && jj_scanpos == jj_lastpos)
3161 return false;
3162 if (jj_3R_101())
3163 return true;
3164 if (jj_la == 0 && jj_scanpos == jj_lastpos)
3165 return false;
3166 return false;
3167 }
3168
3169 final private boolean jj_3_5() {
3170 if (jj_3R_18())
3171 return true;
3172 if (jj_la == 0 && jj_scanpos == jj_lastpos)
3173 return false;
3174 if (jj_scan_token(55))
3175 return true;
3176 if (jj_la == 0 && jj_scanpos == jj_lastpos)
3177 return false;
3178 Token xsp;
3179 xsp = jj_scanpos;
3180 if (jj_3R_19()) {
3181 jj_scanpos = xsp;
3182 if (jj_3R_20()) {
3183 jj_scanpos = xsp;
3184 if (jj_3R_21())
3185 return true;
3186 if (jj_la == 0 && jj_scanpos == jj_lastpos)
3187 return false;
3188 } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
3189 return false;
3190 } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
3191 return false;
3192 if (jj_scan_token(56))
3193 return true;
3194 if (jj_la == 0 && jj_scanpos == jj_lastpos)
3195 return false;
3196 return false;
3197 }
3198
3199 final private boolean jj_3_7() {
3200 if (jj_3R_24())
3201 return true;
3202 if (jj_la == 0 && jj_scanpos == jj_lastpos)
3203 return false;
3204 return false;
3205 }
3206
3207 final private boolean jj_3R_110() {
3208 if (jj_scan_token(37))
3209 return true;
3210 if (jj_la == 0 && jj_scanpos == jj_lastpos)
3211 return false;
3212 if (jj_3R_101())
3213 return true;
3214 if (jj_la == 0 && jj_scanpos == jj_lastpos)
3215 return false;
3216 return false;
3217 }
3218
3219 final private boolean jj_3R_102() {
3220 Token xsp;
3221 xsp = jj_scanpos;
3222 if (jj_3R_110()) {
3223 jj_scanpos = xsp;
3224 if (jj_3R_111()) {
3225 jj_scanpos = xsp;
3226 if (jj_3R_112()) {
3227 jj_scanpos = xsp;
3228 if (jj_3R_113()) {
3229 jj_scanpos = xsp;
3230 if (jj_3R_114())
3231 return true;
3232 if (jj_la == 0 && jj_scanpos == jj_lastpos)
3233 return false;
3234 } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
3235 return false;
3236 } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
3237 return false;
3238 } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
3239 return false;
3240 } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
3241 return false;
3242 return false;
3243 }
3244
3245 final private boolean jj_3R_23() {
3246 Token xsp;
3247 xsp = jj_scanpos;
3248 if (jj_3_7()) {
3249 jj_scanpos = xsp;
3250 if (jj_3R_39()) {
3251 jj_scanpos = xsp;
3252 if (jj_3R_40()) {
3253 jj_scanpos = xsp;
3254 if (jj_3R_41())
3255 return true;
3256 if (jj_la == 0 && jj_scanpos == jj_lastpos)
3257 return false;
3258 } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
3259 return false;
3260 } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
3261 return false;
3262 } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
3263 return false;
3264 return false;
3265 }
3266
3267 final private boolean jj_3R_22() {
3268 if (jj_3R_38())
3269 return true;
3270 if (jj_la == 0 && jj_scanpos == jj_lastpos)
3271 return false;
3272 return false;
3273 }
3274
3275 final private boolean jj_3R_57() {
3276 if (jj_scan_token(55))
3277 return true;
3278 if (jj_la == 0 && jj_scanpos == jj_lastpos)
3279 return false;
3280 Token xsp;
3281 xsp = jj_scanpos;
3282 if (jj_3_4()) {
3283 jj_scanpos = xsp;
3284 if (jj_3R_66()) {
3285 jj_scanpos = xsp;
3286 if (jj_3R_67())
3287 return true;
3288 if (jj_la == 0 && jj_scanpos == jj_lastpos)
3289 return false;
3290 } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
3291 return false;
3292 } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
3293 return false;
3294 if (jj_scan_token(56))
3295 return true;
3296 if (jj_la == 0 && jj_scanpos == jj_lastpos)
3297 return false;
3298 return false;
3299 }
3300
3301 final private boolean jj_3R_91() {
3302 if (jj_3R_101())
3303 return true;
3304 if (jj_la == 0 && jj_scanpos == jj_lastpos)
3305 return false;
3306 Token xsp;
3307 while (true) {
3308 xsp = jj_scanpos;
3309 if (jj_3R_102()) {
3310 jj_scanpos = xsp;
3311 break;
3312 }
3313 if (jj_la == 0 && jj_scanpos == jj_lastpos)
3314 return false;
3315 }
3316 return false;
3317 }
3318
3319 final private boolean jj_3R_42() {
3320 if (jj_3R_49())
3321 return true;
3322 if (jj_la == 0 && jj_scanpos == jj_lastpos)
3323 return false;
3324 Token xsp;
3325 while (true) {
3326 xsp = jj_scanpos;
3327 if (jj_3R_78()) {
3328 jj_scanpos = xsp;
3329 break;
3330 }
3331 if (jj_la == 0 && jj_scanpos == jj_lastpos)
3332 return false;
3333 }
3334 return false;
3335 }
3336
3337 final private boolean jj_3_6() {
3338 if (jj_scan_token(57))
3339 return true;
3340 if (jj_la == 0 && jj_scanpos == jj_lastpos)
3341 return false;
3342 Token xsp;
3343 xsp = jj_scanpos;
3344 if (jj_3R_22()) {
3345 jj_scanpos = xsp;
3346 if (jj_3R_23())
3347 return true;
3348 if (jj_la == 0 && jj_scanpos == jj_lastpos)
3349 return false;
3350 } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
3351 return false;
3352 return false;
3353 }
3354
3355 final private boolean jj_3R_33() {
3356 if (jj_3R_38())
3357 return true;
3358 if (jj_la == 0 && jj_scanpos == jj_lastpos)
3359 return false;
3360 return false;
3361 }
3362
3363 final private boolean jj_3R_48() {
3364 if (jj_scan_token(14))
3365 return true;
3366 if (jj_la == 0 && jj_scanpos == jj_lastpos)
3367 return false;
3368 if (jj_scan_token(12))
3369 return true;
3370 if (jj_la == 0 && jj_scanpos == jj_lastpos)
3371 return false;
3372 if (jj_scan_token(13))
3373 return true;
3374 if (jj_la == 0 && jj_scanpos == jj_lastpos)
3375 return false;
3376 return false;
3377 }
3378
3379 final private boolean jj_3R_104() {
3380 if (jj_scan_token(36))
3381 return true;
3382 if (jj_la == 0 && jj_scanpos == jj_lastpos)
3383 return false;
3384 if (jj_3R_91())
3385 return true;
3386 if (jj_la == 0 && jj_scanpos == jj_lastpos)
3387 return false;
3388 return false;
3389 }
3390
3391 final private boolean jj_3R_16() {
3392 Token xsp;
3393 xsp = jj_scanpos;
3394 if (jj_3R_33()) {
3395 jj_scanpos = xsp;
3396 if (jj_3R_34())
3397 return true;
3398 if (jj_la == 0 && jj_scanpos == jj_lastpos)
3399 return false;
3400 } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
3401 return false;
3402 while (true) {
3403 xsp = jj_scanpos;
3404 if (jj_3_6()) {
3405 jj_scanpos = xsp;
3406 break;
3407 }
3408 if (jj_la == 0 && jj_scanpos == jj_lastpos)
3409 return false;
3410 }
3411 return false;
3412 }
3413
3414 final private boolean jj_3R_103() {
3415 if (jj_scan_token(35))
3416 return true;
3417 if (jj_la == 0 && jj_scanpos == jj_lastpos)
3418 return false;
3419 if (jj_3R_91())
3420 return true;
3421 if (jj_la == 0 && jj_scanpos == jj_lastpos)
3422 return false;
3423 return false;
3424 }
3425
3426 final private boolean jj_3R_92() {
3427 Token xsp;
3428 xsp = jj_scanpos;
3429 if (jj_3R_103()) {
3430 jj_scanpos = xsp;
3431 if (jj_3R_104())
3432 return true;
3433 if (jj_la == 0 && jj_scanpos == jj_lastpos)
3434 return false;
3435 } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
3436 return false;
3437 return false;
3438 }
3439
3440 final private boolean jj_3R_85() {
3441 if (jj_3R_91())
3442 return true;
3443 if (jj_la == 0 && jj_scanpos == jj_lastpos)
3444 return false;
3445 Token xsp;
3446 while (true) {
3447 xsp = jj_scanpos;
3448 if (jj_3R_92()) {
3449 jj_scanpos = xsp;
3450 break;
3451 }
3452 if (jj_la == 0 && jj_scanpos == jj_lastpos)
3453 return false;
3454 }
3455 return false;
3456 }
3457
3458 final private boolean jj_3R_38() {
3459 if (jj_3R_18())
3460 return true;
3461 if (jj_la == 0 && jj_scanpos == jj_lastpos)
3462 return false;
3463 Token xsp;
3464 if (jj_3R_57())
3465 return true;
3466 if (jj_la == 0 && jj_scanpos == jj_lastpos)
3467 return false;
3468 while (true) {
3469 xsp = jj_scanpos;
3470 if (jj_3R_57()) {
3471 jj_scanpos = xsp;
3472 break;
3473 }
3474 if (jj_la == 0 && jj_scanpos == jj_lastpos)
3475 return false;
3476 }
3477 return false;
3478 }
3479
3480 final private boolean jj_3R_100() {
3481 if (jj_scan_token(34))
3482 return true;
3483 if (jj_la == 0 && jj_scanpos == jj_lastpos)
3484 return false;
3485 if (jj_3R_85())
3486 return true;
3487 if (jj_la == 0 && jj_scanpos == jj_lastpos)
3488 return false;
3489 return false;
3490 }
3491
3492 final private boolean jj_3R_99() {
3493 if (jj_scan_token(33))
3494 return true;
3495 if (jj_la == 0 && jj_scanpos == jj_lastpos)
3496 return false;
3497 if (jj_3R_85())
3498 return true;
3499 if (jj_la == 0 && jj_scanpos == jj_lastpos)
3500 return false;
3501 return false;
3502 }
3503
3504 final private boolean jj_3R_24() {
3505 if (jj_3R_18())
3506 return true;
3507 if (jj_la == 0 && jj_scanpos == jj_lastpos)
3508 return false;
3509 if (jj_scan_token(12))
3510 return true;
3511 if (jj_la == 0 && jj_scanpos == jj_lastpos)
3512 return false;
3513 Token xsp;
3514 xsp = jj_scanpos;
3515 if (jj_3R_42())
3516 jj_scanpos = xsp;
3517 else if (jj_la == 0 && jj_scanpos == jj_lastpos)
3518 return false;
3519 if (jj_scan_token(13))
3520 return true;
3521 if (jj_la == 0 && jj_scanpos == jj_lastpos)
3522 return false;
3523 return false;
3524 }
3525
3526 final private boolean jj_3R_98() {
3527 if (jj_scan_token(32))
3528 return true;
3529 if (jj_la == 0 && jj_scanpos == jj_lastpos)
3530 return false;
3531 if (jj_3R_85())
3532 return true;
3533 if (jj_la == 0 && jj_scanpos == jj_lastpos)
3534 return false;
3535 return false;
3536 }
3537
3538 final private boolean jj_3R_97() {
3539 if (jj_scan_token(31))
3540 return true;
3541 if (jj_la == 0 && jj_scanpos == jj_lastpos)
3542 return false;
3543 if (jj_3R_85())
3544 return true;
3545 if (jj_la == 0 && jj_scanpos == jj_lastpos)
3546 return false;
3547 return false;
3548 }
3549
3550 final private boolean jj_3R_96() {
3551 if (jj_scan_token(30))
3552 return true;
3553 if (jj_la == 0 && jj_scanpos == jj_lastpos)
3554 return false;
3555 if (jj_3R_85())
3556 return true;
3557 if (jj_la == 0 && jj_scanpos == jj_lastpos)
3558 return false;
3559 return false;
3560 }
3561
3562 final private boolean jj_3R_95() {
3563 if (jj_scan_token(29))
3564 return true;
3565 if (jj_la == 0 && jj_scanpos == jj_lastpos)
3566 return false;
3567 if (jj_3R_85())
3568 return true;
3569 if (jj_la == 0 && jj_scanpos == jj_lastpos)
3570 return false;
3571 return false;
3572 }
3573
3574 final private boolean jj_3R_94() {
3575 if (jj_scan_token(28))
3576 return true;
3577 if (jj_la == 0 && jj_scanpos == jj_lastpos)
3578 return false;
3579 if (jj_3R_85())
3580 return true;
3581 if (jj_la == 0 && jj_scanpos == jj_lastpos)
3582 return false;
3583 return false;
3584 }
3585
3586 final private boolean jj_3R_93() {
3587 if (jj_scan_token(27))
3588 return true;
3589 if (jj_la == 0 && jj_scanpos == jj_lastpos)
3590 return false;
3591 if (jj_3R_85())
3592 return true;
3593 if (jj_la == 0 && jj_scanpos == jj_lastpos)
3594 return false;
3595 return false;
3596 }
3597
3598 final private boolean jj_3R_86() {
3599 Token xsp;
3600 xsp = jj_scanpos;
3601 if (jj_3R_93()) {
3602 jj_scanpos = xsp;
3603 if (jj_3R_94()) {
3604 jj_scanpos = xsp;
3605 if (jj_3R_95()) {
3606 jj_scanpos = xsp;
3607 if (jj_3R_96()) {
3608 jj_scanpos = xsp;
3609 if (jj_3R_97()) {
3610 jj_scanpos = xsp;
3611 if (jj_3R_98()) {
3612 jj_scanpos = xsp;
3613 if (jj_3R_99()) {
3614 jj_scanpos = xsp;
3615 if (jj_3R_100())
3616 return true;
3617 if (jj_la == 0 && jj_scanpos == jj_lastpos)
3618 return false;
3619 } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
3620 return false;
3621 } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
3622 return false;
3623 } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
3624 return false;
3625 } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
3626 return false;
3627 } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
3628 return false;
3629 } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
3630 return false;
3631 } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
3632 return false;
3633 return false;
3634 }
3635
3636 final private boolean jj_3R_83() {
3637 if (jj_3R_85())
3638 return true;
3639 if (jj_la == 0 && jj_scanpos == jj_lastpos)
3640 return false;
3641 Token xsp;
3642 while (true) {
3643 xsp = jj_scanpos;
3644 if (jj_3R_86()) {
3645 jj_scanpos = xsp;
3646 break;
3647 }
3648 if (jj_la == 0 && jj_scanpos == jj_lastpos)
3649 return false;
3650 }
3651 return false;
3652 }
3653
3654 final private boolean jj_3R_90() {
3655 if (jj_scan_token(26))
3656 return true;
3657 if (jj_la == 0 && jj_scanpos == jj_lastpos)
3658 return false;
3659 if (jj_3R_83())
3660 return true;
3661 if (jj_la == 0 && jj_scanpos == jj_lastpos)
3662 return false;
3663 return false;
3664 }
3665
3666 final private boolean jj_3R_89() {
3667 if (jj_scan_token(25))
3668 return true;
3669 if (jj_la == 0 && jj_scanpos == jj_lastpos)
3670 return false;
3671 if (jj_3R_83())
3672 return true;
3673 if (jj_la == 0 && jj_scanpos == jj_lastpos)
3674 return false;
3675 return false;
3676 }
3677
3678 final private boolean jj_3R_88() {
3679 if (jj_scan_token(24))
3680 return true;
3681 if (jj_la == 0 && jj_scanpos == jj_lastpos)
3682 return false;
3683 if (jj_3R_83())
3684 return true;
3685 if (jj_la == 0 && jj_scanpos == jj_lastpos)
3686 return false;
3687 return false;
3688 }
3689
3690 final private boolean jj_3R_87() {
3691 if (jj_scan_token(23))
3692 return true;
3693 if (jj_la == 0 && jj_scanpos == jj_lastpos)
3694 return false;
3695 if (jj_3R_83())
3696 return true;
3697 if (jj_la == 0 && jj_scanpos == jj_lastpos)
3698 return false;
3699 return false;
3700 }
3701
3702 final private boolean jj_3R_84() {
3703 Token xsp;
3704 xsp = jj_scanpos;
3705 if (jj_3R_87()) {
3706 jj_scanpos = xsp;
3707 if (jj_3R_88()) {
3708 jj_scanpos = xsp;
3709 if (jj_3R_89()) {
3710 jj_scanpos = xsp;
3711 if (jj_3R_90())
3712 return true;
3713 if (jj_la == 0 && jj_scanpos == jj_lastpos)
3714 return false;
3715 } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
3716 return false;
3717 } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
3718 return false;
3719 } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
3720 return false;
3721 return false;
3722 }
3723
3724 final private boolean jj_3R_81() {
3725 if (jj_3R_83())
3726 return true;
3727 if (jj_la == 0 && jj_scanpos == jj_lastpos)
3728 return false;
3729 Token xsp;
3730 while (true) {
3731 xsp = jj_scanpos;
3732 if (jj_3R_84()) {
3733 jj_scanpos = xsp;
3734 break;
3735 }
3736 if (jj_la == 0 && jj_scanpos == jj_lastpos)
3737 return false;
3738 }
3739 return false;
3740 }
3741
3742 final private boolean jj_3R_82() {
3743 if (jj_scan_token(22))
3744 return true;
3745 if (jj_la == 0 && jj_scanpos == jj_lastpos)
3746 return false;
3747 if (jj_3R_81())
3748 return true;
3749 if (jj_la == 0 && jj_scanpos == jj_lastpos)
3750 return false;
3751 return false;
3752 }
3753
3754 final private boolean jj_3R_79() {
3755 if (jj_3R_81())
3756 return true;
3757 if (jj_la == 0 && jj_scanpos == jj_lastpos)
3758 return false;
3759 Token xsp;
3760 while (true) {
3761 xsp = jj_scanpos;
3762 if (jj_3R_82()) {
3763 jj_scanpos = xsp;
3764 break;
3765 }
3766 if (jj_la == 0 && jj_scanpos == jj_lastpos)
3767 return false;
3768 }
3769 return false;
3770 }
3771
3772 final private boolean jj_3_3() {
3773 if (jj_3R_15())
3774 return true;
3775 if (jj_la == 0 && jj_scanpos == jj_lastpos)
3776 return false;
3777 if (jj_scan_token(15))
3778 return true;
3779 if (jj_la == 0 && jj_scanpos == jj_lastpos)
3780 return false;
3781 return false;
3782 }
3783
3784 final private boolean jj_3_2() {
3785 if (jj_3R_16())
3786 return true;
3787 if (jj_la == 0 && jj_scanpos == jj_lastpos)
3788 return false;
3789 if (jj_scan_token(48))
3790 return true;
3791 if (jj_la == 0 && jj_scanpos == jj_lastpos)
3792 return false;
3793 return false;
3794 }
3795
3796 final private boolean jj_3R_80() {
3797 if (jj_scan_token(21))
3798 return true;
3799 if (jj_la == 0 && jj_scanpos == jj_lastpos)
3800 return false;
3801 if (jj_3R_79())
3802 return true;
3803 if (jj_la == 0 && jj_scanpos == jj_lastpos)
3804 return false;
3805 return false;
3806 }
3807
3808 final private boolean jj_3R_74() {
3809 if (jj_3R_79())
3810 return true;
3811 if (jj_la == 0 && jj_scanpos == jj_lastpos)
3812 return false;
3813 Token xsp;
3814 while (true) {
3815 xsp = jj_scanpos;
3816 if (jj_3R_80()) {
3817 jj_scanpos = xsp;
3818 break;
3819 }
3820 if (jj_la == 0 && jj_scanpos == jj_lastpos)
3821 return false;
3822 }
3823 return false;
3824 }
3825
3826 final private boolean jj_3R_75() {
3827 if (jj_scan_token(20))
3828 return true;
3829 if (jj_la == 0 && jj_scanpos == jj_lastpos)
3830 return false;
3831 if (jj_3R_74())
3832 return true;
3833 if (jj_la == 0 && jj_scanpos == jj_lastpos)
3834 return false;
3835 return false;
3836 }
3837
3838 final private boolean jj_3R_68() {
3839 if (jj_3R_74())
3840 return true;
3841 if (jj_la == 0 && jj_scanpos == jj_lastpos)
3842 return false;
3843 Token xsp;
3844 while (true) {
3845 xsp = jj_scanpos;
3846 if (jj_3R_75()) {
3847 jj_scanpos = xsp;
3848 break;
3849 }
3850 if (jj_la == 0 && jj_scanpos == jj_lastpos)
3851 return false;
3852 }
3853 return false;
3854 }
3855
3856 final private boolean jj_3R_77() {
3857 if (jj_scan_token(19))
3858 return true;
3859 if (jj_la == 0 && jj_scanpos == jj_lastpos)
3860 return false;
3861 if (jj_3R_68())
3862 return true;
3863 if (jj_la == 0 && jj_scanpos == jj_lastpos)
3864 return false;
3865 return false;
3866 }
3867
3868 final private boolean jj_3R_69() {
3869 Token xsp;
3870 xsp = jj_scanpos;
3871 if (jj_3R_76()) {
3872 jj_scanpos = xsp;
3873 if (jj_3R_77())
3874 return true;
3875 if (jj_la == 0 && jj_scanpos == jj_lastpos)
3876 return false;
3877 } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
3878 return false;
3879 return false;
3880 }
3881
3882 final private boolean jj_3R_76() {
3883 if (jj_scan_token(18))
3884 return true;
3885 if (jj_la == 0 && jj_scanpos == jj_lastpos)
3886 return false;
3887 if (jj_3R_68())
3888 return true;
3889 if (jj_la == 0 && jj_scanpos == jj_lastpos)
3890 return false;
3891 return false;
3892 }
3893
3894 final private boolean jj_3R_58() {
3895 if (jj_3R_68())
3896 return true;
3897 if (jj_la == 0 && jj_scanpos == jj_lastpos)
3898 return false;
3899 Token xsp;
3900 while (true) {
3901 xsp = jj_scanpos;
3902 if (jj_3R_69()) {
3903 jj_scanpos = xsp;
3904 break;
3905 }
3906 if (jj_la == 0 && jj_scanpos == jj_lastpos)
3907 return false;
3908 }
3909 return false;
3910 }
3911
3912 public ParserTokenManager token_source;
3913
3914 SimpleCharStream jj_input_stream;
3915
3916 public Token token, jj_nt;
3917
3918 private int jj_ntk;
3919
3920 private Token jj_scanpos, jj_lastpos;
3921
3922 private int jj_la;
3923
3924 public boolean lookingAhead = false;
3925
3926 private boolean jj_semLA;
3927
3928 private int jj_gen;
3929
3930 final private int[] jj_la1 = new int[34];
3931
3932 final private int[] jj_la1_0 = { 0x5b80, 0x5b80, 0x1000, 0x5980, 0x30000, 0x30000, 0xc0000, 0xc0000, 0x100000,
3933 0x200000, 0x400000, 0x7800000, 0x7800000, 0xf8000000, 0xf8000000, 0x0, 0x0, 0x0, 0x0, 0x5980, 0x5980, 0x180,
3934 0x0, 0x200, 0x5980, 0x0, 0x0, 0x5980, 0x80, 0x0, 0x0, 0x4080, 0x4080, 0x180, };
3935
3936 final private int[] jj_la1_1 = { 0x241bfc10, 0x241bfc10, 0x4000000, 0x2400fc10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
3937 0x0, 0x0, 0x7, 0x7, 0x18, 0x18, 0x3e0, 0x3e0, 0x2400fc10, 0x2400e000, 0x2000e000, 0xc000, 0x10000, 0x241afc10,
3938 0x40000, 0x400000, 0x2400fc10, 0x4000000, 0x800000, 0x4000000, 0x4000000, 0x4000000, 0x2400e000, };
3939
3940 final private JJCalls[] jj_2_rtns = new JJCalls[9];
3941
3942 private boolean jj_rescan = false;
3943
3944 private int jj_gc = 0;
3945
3946 public Parser(java.io.InputStream stream) {
3947 jj_input_stream = new SimpleCharStream(stream, 1, 1);
3948 token_source = new ParserTokenManager(jj_input_stream);
3949 token = new Token();
3950 jj_ntk = -1;
3951 jj_gen = 0;
3952 for (int i = 0; i < 34; i++)
3953 jj_la1[i] = -1;
3954 for (int i = 0; i < jj_2_rtns.length; i++)
3955 jj_2_rtns[i] = new JJCalls();
3956 }
3957
3958 public void ReInit(java.io.InputStream stream) {
3959 jj_input_stream.ReInit(stream, 1, 1);
3960 token_source.ReInit(jj_input_stream);
3961 token = new Token();
3962 jj_ntk = -1;
3963 jjtree.reset();
3964 jj_gen = 0;
3965 for (int i = 0; i < 34; i++)
3966 jj_la1[i] = -1;
3967 for (int i = 0; i < jj_2_rtns.length; i++)
3968 jj_2_rtns[i] = new JJCalls();
3969 }
3970
3971 public Parser(java.io.Reader stream) {
3972 jj_input_stream = new SimpleCharStream(stream, 1, 1);
3973 token_source = new ParserTokenManager(jj_input_stream);
3974 token = new Token();
3975 jj_ntk = -1;
3976 jj_gen = 0;
3977 for (int i = 0; i < 34; i++)
3978 jj_la1[i] = -1;
3979 for (int i = 0; i < jj_2_rtns.length; i++)
3980 jj_2_rtns[i] = new JJCalls();
3981 }
3982
3983 public void ReInit(java.io.Reader stream) {
3984 jj_input_stream.ReInit(stream, 1, 1);
3985 token_source.ReInit(jj_input_stream);
3986 token = new Token();
3987 jj_ntk = -1;
3988 jjtree.reset();
3989 jj_gen = 0;
3990 for (int i = 0; i < 34; i++)
3991 jj_la1[i] = -1;
3992 for (int i = 0; i < jj_2_rtns.length; i++)
3993 jj_2_rtns[i] = new JJCalls();
3994 }
3995
3996 public Parser(ParserTokenManager tm) {
3997 token_source = tm;
3998 token = new Token();
3999 jj_ntk = -1;
4000 jj_gen = 0;
4001 for (int i = 0; i < 34; i++)
4002 jj_la1[i] = -1;
4003 for (int i = 0; i < jj_2_rtns.length; i++)
4004 jj_2_rtns[i] = new JJCalls();
4005 }
4006
4007 public void ReInit(ParserTokenManager tm) {
4008 token_source = tm;
4009 token = new Token();
4010 jj_ntk = -1;
4011 jjtree.reset();
4012 jj_gen = 0;
4013 for (int i = 0; i < 34; i++)
4014 jj_la1[i] = -1;
4015 for (int i = 0; i < jj_2_rtns.length; i++)
4016 jj_2_rtns[i] = new JJCalls();
4017 }
4018
4019 final private Token jj_consume_token(int kind) throws ParseException {
4020 Token oldToken;
4021 if ((oldToken = token).next != null)
4022 token = token.next;
4023 else
4024 token = token.next = token_source.getNextToken();
4025 jj_ntk = -1;
4026 if (token.kind == kind) {
4027 jj_gen++;
4028 if (++jj_gc > 100) {
4029 jj_gc = 0;
4030 for (int i = 0; i < jj_2_rtns.length; i++) {
4031 JJCalls c = jj_2_rtns[i];
4032 while (c != null) {
4033 if (c.gen < jj_gen)
4034 c.first = null;
4035 c = c.next;
4036 }
4037 }
4038 }
4039 return token;
4040 }
4041 token = oldToken;
4042 jj_kind = kind;
4043 throw generateParseException();
4044 }
4045
4046 final private boolean jj_scan_token(int kind) {
4047 if (jj_scanpos == jj_lastpos) {
4048 jj_la--;
4049 if (jj_scanpos.next == null) {
4050 jj_lastpos = jj_scanpos = jj_scanpos.next = token_source.getNextToken();
4051 } else {
4052 jj_lastpos = jj_scanpos = jj_scanpos.next;
4053 }
4054 } else {
4055 jj_scanpos = jj_scanpos.next;
4056 }
4057 if (jj_rescan) {
4058 int i = 0;
4059 Token tok = token;
4060 while (tok != null && tok != jj_scanpos) {
4061 i++;
4062 tok = tok.next;
4063 }
4064 if (tok != null)
4065 jj_add_error_token(kind, i);
4066 }
4067 return (jj_scanpos.kind != kind);
4068 }
4069
4070 final public Token getNextToken() {
4071 if (token.next != null)
4072 token = token.next;
4073 else
4074 token = token.next = token_source.getNextToken();
4075 jj_ntk = -1;
4076 jj_gen++;
4077 return token;
4078 }
4079
4080 final public Token getToken(int index) {
4081 Token t = lookingAhead ? jj_scanpos : token;
4082 for (int i = 0; i < index; i++) {
4083 if (t.next != null)
4084 t = t.next;
4085 else
4086 t = t.next = token_source.getNextToken();
4087 }
4088 return t;
4089 }
4090
4091 final private int jj_ntk() {
4092 if ((jj_nt = token.next) == null)
4093 return (jj_ntk = (token.next = token_source.getNextToken()).kind);
4094 else
4095 return (jj_ntk = jj_nt.kind);
4096 }
4097
4098 private java.util.Vector jj_expentries = new java.util.Vector ();
4099
4100 private int[] jj_expentry;
4101
4102 private int jj_kind = -1;
4103
4104 private int[] jj_lasttokens = new int[100];
4105
4106 private int jj_endpos;
4107
4108 private void jj_add_error_token(int kind, int pos) {
4109 if (pos >= 100)
4110 return;
4111 if (pos == jj_endpos + 1) {
4112 jj_lasttokens[jj_endpos++] = kind;
4113 } else if (jj_endpos != 0) {
4114 jj_expentry = new int[jj_endpos];
4115 for (int i = 0; i < jj_endpos; i++) {
4116 jj_expentry[i] = jj_lasttokens[i];
4117 }
4118 boolean exists = false;
4119 for (java.util.Enumeration enumeration = jj_expentries.elements(); enumeration.hasMoreElements();) {
4120 int[] oldentry = (int[]) (enumeration.nextElement());
4121 if (oldentry.length == jj_expentry.length) {
4122 exists = true;
4123 for (int i = 0; i < jj_expentry.length; i++) {
4124 if (oldentry[i] != jj_expentry[i]) {
4125 exists = false;
4126 break;
4127 }
4128 }
4129 if (exists)
4130 break;
4131 }
4132 }
4133 if (!exists)
4134 jj_expentries.addElement(jj_expentry);
4135 if (pos != 0)
4136 jj_lasttokens[(jj_endpos = pos) - 1] = kind;
4137 }
4138 }
4139
4140 final public ParseException generateParseException() {
4141 jj_expentries.removeAllElements();
4142 boolean[] la1tokens = new boolean[62];
4143 for (int i = 0; i < 62; i++) {
4144 la1tokens[i] = false;
4145 }
4146 if (jj_kind >= 0) {
4147 la1tokens[jj_kind] = true;
4148 jj_kind = -1;
4149 }
4150 for (int i = 0; i < 34; i++) {
4151 if (jj_la1[i] == jj_gen) {
4152 for (int j = 0; j < 32; j++) {
4153 if ((jj_la1_0[i] & (1 << j)) != 0) {
4154 la1tokens[j] = true;
4155 }
4156 if ((jj_la1_1[i] & (1 << j)) != 0) {
4157 la1tokens[32 + j] = true;
4158 }
4159 }
4160 }
4161 }
4162 for (int i = 0; i < 62; i++) {
4163 if (la1tokens[i]) {
4164 jj_expentry = new int[1];
4165 jj_expentry[0] = i;
4166 jj_expentries.addElement(jj_expentry);
4167 }
4168 }
4169 jj_endpos = 0;
4170 jj_rescan_token();
4171 jj_add_error_token(0, 0);
4172 int[][] exptokseq = new int[jj_expentries.size()][];
4173 for (int i = 0; i < jj_expentries.size(); i++) {
4174 exptokseq[i] = (int[]) jj_expentries.elementAt(i);
4175 }
4176 return new ParseException(token, exptokseq, tokenImage);
4177 }
4178
4179 final public void enable_tracing() {
4180 }
4181
4182 final public void disable_tracing() {
4183 }
4184
4185 final private void jj_rescan_token() {
4186 jj_rescan = true;
4187 for (int i = 0; i < 9; i++) {
4188 JJCalls p = jj_2_rtns[i];
4189 do {
4190 if (p.gen > jj_gen) {
4191 jj_la = p.arg;
4192 jj_lastpos = jj_scanpos = p.first;
4193 switch (i) {
4194 case 0:
4195 jj_3_1();
4196 break;
4197 case 1:
4198 jj_3_2();
4199 break;
4200 case 2:
4201 jj_3_3();
4202 break;
4203 case 3:
4204 jj_3_4();
4205 break;
4206 case 4:
4207 jj_3_5();
4208 break;
4209 case 5:
4210 jj_3_6();
4211 break;
4212 case 6:
4213 jj_3_7();
4214 break;
4215 case 7:
4216 jj_3_8();
4217 break;
4218 case 8:
4219 jj_3_9();
4220 break;
4221 }
4222 }
4223 p = p.next;
4224 } while (p != null);
4225 }
4226 jj_rescan = false;
4227 }
4228
4229 final private void jj_save(int index, int xla) {
4230 JJCalls p = jj_2_rtns[index];
4231 while (p.gen > jj_gen) {
4232 if (p.next == null) {
4233 p = p.next = new JJCalls();
4234 break;
4235 }
4236 p = p.next;
4237 }
4238 p.gen = jj_gen + xla - jj_la;
4239 p.first = token;
4240 p.arg = xla;
4241 }
4242
4243 static final class JJCalls {
4244 int gen;
4245
4246 Token first;
4247
4248 int arg;
4249
4250 JJCalls next;
4251 }
4252
4253}
4254 |
Popular Tags |
Java API By Example, From Geeks To Geeks.