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