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