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