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