1
2
3 package org.apache.commons.jexl3.parser;
4
5 import java.util.Collections;
6 import java.util.List;
7 import java.util.ArrayList;
8 import java.util.LinkedList;
9
10 import org.apache.commons.jexl3.JexlInfo;
11 import org.apache.commons.jexl3.JexlFeatures;
12 import org.apache.commons.jexl3.JexlException;
13 import org.apache.commons.jexl3.internal.Scope;
14
15 public final class Parser extends JexlParserimplements ParserTreeConstants, ParserConstants {
16 protected JJTParserState jjtree = new JJTParserState();public Parser(JexlParser parser) {
17 super(parser);
18 jj_input_stream = new SimpleCharStream(new StringProvider(""), 1, 1);
19 token_source = new ParserTokenManager(jj_input_stream);
20 token = new Token();
21 token.next = jj_nt = token_source.getNextToken();
22 }
23
24
25
26
27
28
29
30
31
32
33
34 public ASTJexlScript parse(JexlInfo jexlInfo, JexlFeatures jexlFeatures, String jexlSrc, Scope jexlScope) {
35 JexlFeatures previous = getFeatures();
36 try {
37
38 this.info = jexlInfo != null? jexlInfo : new JexlInfo();
39 this.source = jexlSrc;
40 if (this.parent == null) {
41 setFeatures(jexlFeatures);
42 this.pragmas = null;
43 }
44 this.scopeReference.set(jexlScope);
45 token_source.comparatorNames = jexlFeatures.supportsComparatorNames();
46 ReInit(jexlSrc);
47 ASTJexlScript script = jexlFeatures.supportsScript()
48 ? JexlScript(jexlScope, jexlFeatures)
49 : JexlExpression(jexlScope, jexlFeatures);
50 script.jjtSetValue(info.detach());
51 script.setPragmas(pragmas != null
52 ? Collections.unmodifiableMap(pragmas)
53 : Collections.emptyMap());
54 return script;
55 } catch (TokenMgrException xtme) {
56 throw new JexlException.Tokenization(info, xtme).clean();
57 } catch (ParseException xparse) {
58 Token errortok = errorToken(jj_lastpos, jj_scanpos, token.next, token);
59 throw new JexlException.Parsing(info.at(errortok.beginLine, errortok.beginColumn), errortok.image).clean();
60 } finally {
61 token_source.defaultLexState = DEFAULT;
62 cleanup(previous);
63 jjtree.reset();
64 }
65 }
66
67
68
69
70 final public
71 ASTJexlScript JexlScript(Scope frame, JexlFeatures features) throws ParseException {
72 ASTJexlScript jjtn000 = new ASTJexlScript(JJTJEXLSCRIPT);
73 boolean jjtc000 = true;
74 jjtree.openNodeScope(jjtn000);
75 jjtreeOpenNodeScope(jjtn000);
76 jjtn000.jjtSetFirstToken(getToken(1));jjtn000.setScope(frame);
77 jjtn000.setFeatures(features);
78 try {
79 pushUnit(jjtn000);
80 label_1:
81 while (true) {
82 switch (jj_nt.kind) {
83 case IMPORT:{
84 break;
85 }
86 default:
87 break label_1;
88 }
89 Import();
90 }
91 label_2:
92 while (true) {
93 if (jj_2_1(1)) {
94 } else {
95 break label_2;
96 }
97 switch (jj_nt.kind) {
98 case PRAGMA:{
99 Pragma();
100 break;
101 }
102 default:
103 if (jj_2_2(1)) {
104 controlPragmaAnywhere();
105 Statement();
106 } else {
107 jj_consume_token(-1);
108 throw new ParseException();
109 }
110 }
111 }
112 jj_consume_token(0);
113 jjtree.closeNodeScope(jjtn000, true);
114 jjtc000 = false;
115 if (jjtree.nodeCreated()) {
116 jjtreeCloseNodeScope(jjtn000);
117 }
118 jjtn000.jjtSetLastToken(getToken(0));
119 popUnit(jjtn000);
120 {if ("" != null) return jjtn000.script();}
121 } catch (Throwable jjte000) {
122 if (jjtc000) {
123 jjtree.clearNodeScope(jjtn000);
124 jjtc000 = false;
125 } else {
126 jjtree.popNode();
127 }
128 if (jjte000 instanceof ParseException) {
129 throw (ParseException)jjte000;
130 }
131 if (jjte000 instanceof RuntimeException) {
132 throw (RuntimeException)jjte000;
133 }
134 throw (Error)jjte000;
135 } finally {
136 if (jjtc000) {
137 jjtree.closeNodeScope(jjtn000, true);
138 if (jjtree.nodeCreated()) {
139 jjtreeCloseNodeScope(jjtn000);
140 }
141 jjtn000.jjtSetLastToken(getToken(0));
142 }
143 }
144 throw new IllegalStateException ("Missing return statement in function");
145 }
146
147 final public ASTJexlScript JexlExpression(Scope frame, JexlFeatures features) throws ParseException {
148 ASTJexlScript jjtn000 = new ASTJexlScript(JJTJEXLSCRIPT);
149 boolean jjtc000 = true;
150 jjtree.openNodeScope(jjtn000);
151 jjtreeOpenNodeScope(jjtn000);
152 jjtn000.jjtSetFirstToken(getToken(1));jjtn000.setScope(frame);
153 jjtn000.setFeatures(features);
154 try {
155 pushUnit(jjtn000);
156 label_3:
157 while (true) {
158 switch (jj_nt.kind) {
159 case PRAGMA:{
160 break;
161 }
162 default:
163 break label_3;
164 }
165 Pragma();
166 }
167 controlPragmaAnywhere();
168 if (jj_2_3(1)) {
169 Expression();
170 } else {
171 ;
172 }
173 jj_consume_token(0);
174 jjtree.closeNodeScope(jjtn000, true);
175 jjtc000 = false;
176 if (jjtree.nodeCreated()) {
177 jjtreeCloseNodeScope(jjtn000);
178 }
179 jjtn000.jjtSetLastToken(getToken(0));
180 popUnit(jjtn000);
181 {if ("" != null) return jjtn000.script();}
182 } catch (Throwable jjte000) {
183 if (jjtc000) {
184 jjtree.clearNodeScope(jjtn000);
185 jjtc000 = false;
186 } else {
187 jjtree.popNode();
188 }
189 if (jjte000 instanceof ParseException) {
190 throw (ParseException)jjte000;
191 }
192 if (jjte000 instanceof RuntimeException) {
193 throw (RuntimeException)jjte000;
194 }
195 throw (Error)jjte000;
196 } finally {
197 if (jjtc000) {
198 jjtree.closeNodeScope(jjtn000, true);
199 if (jjtree.nodeCreated()) {
200 jjtreeCloseNodeScope(jjtn000);
201 }
202 jjtn000.jjtSetLastToken(getToken(0));
203 }
204 }
205 throw new IllegalStateException ("Missing return statement in function");
206 }
207
208 final public void Annotation() throws ParseException {
209 ASTAnnotation jjtn000 = new ASTAnnotation(JJTANNOTATION);
210 boolean jjtc000 = true;
211 jjtree.openNodeScope(jjtn000);
212 jjtreeOpenNodeScope(jjtn000);
213 jjtn000.jjtSetFirstToken(getToken(1));Token t;
214 try {
215 t = jj_consume_token(ANNOTATION);
216 jjtn000.setName(t.image);
217 if (jj_2_4(2)) {
218 Arguments();
219 } else {
220 ;
221 }
222 } catch (Throwable jjte000) {
223 if (jjtc000) {
224 jjtree.clearNodeScope(jjtn000);
225 jjtc000 = false;
226 } else {
227 jjtree.popNode();
228 }
229 if (jjte000 instanceof ParseException) {
230 throw (ParseException)jjte000;
231 }
232 if (jjte000 instanceof RuntimeException) {
233 throw (RuntimeException)jjte000;
234 }
235 throw (Error)jjte000;
236 } finally {
237 if (jjtc000) {
238 jjtree.closeNodeScope(jjtn000, true);
239 if (jjtree.nodeCreated()) {
240 jjtreeCloseNodeScope(jjtn000);
241 }
242 jjtn000.jjtSetLastToken(getToken(0));
243 }
244 }
245 }
246
247 final public void AnnotatedStatement() throws ParseException {
248 ASTAnnotatedStatement jjtn000 = new ASTAnnotatedStatement(JJTANNOTATEDSTATEMENT);
249 boolean jjtc000 = true;
250 jjtree.openNodeScope(jjtn000);
251 jjtreeOpenNodeScope(jjtn000);
252 jjtn000.jjtSetFirstToken(getToken(1));
253 try {
254 label_4:
255 while (true) {
256 Annotation();
257 if (jj_2_5(2)) {
258 } else {
259 break label_4;
260 }
261 }
262 if (jj_2_6(2147483647)) {
263 Expression();
264 } else if (jj_2_7(1)) {
265 Statement();
266 } else {
267 jj_consume_token(-1);
268 throw new ParseException();
269 }
270 } catch (Throwable jjte000) {
271 if (jjtc000) {
272 jjtree.clearNodeScope(jjtn000);
273 jjtc000 = false;
274 } else {
275 jjtree.popNode();
276 }
277 if (jjte000 instanceof ParseException) {
278 throw (ParseException)jjte000;
279 }
280 if (jjte000 instanceof RuntimeException) {
281 throw (RuntimeException)jjte000;
282 }
283 throw (Error)jjte000;
284 } finally {
285 if (jjtc000) {
286 jjtree.closeNodeScope(jjtn000, true);
287 if (jjtree.nodeCreated()) {
288 jjtreeCloseNodeScope(jjtn000);
289 }
290 jjtn000.jjtSetLastToken(getToken(0));
291 }
292 }
293 }
294
295 final public void Statement() throws ParseException {
296 if (jj_2_8(3)) {
297 Var();
298 } else if (jj_2_9(3)) {
299 FunctionStatement();
300 } else if (jj_2_10(1)) {
301 StatementSink();
302 } else {
303 jj_consume_token(-1);
304 throw new ParseException();
305 }
306 }
307
308 final public void StatementSink() throws ParseException {
309 switch (jj_nt.kind) {
310 case SEMICOL:{
311 jj_consume_token(SEMICOL);
312 break;
313 }
314 case ANNOTATION:{
315 AnnotatedStatement();
316 break;
317 }
318 case IF:{
319 IfStatement();
320 break;
321 }
322 case FOR:{
323 ForeachStatement();
324 break;
325 }
326 case WHILE:{
327 WhileStatement();
328 break;
329 }
330 case DO:{
331 DoWhileStatement();
332 break;
333 }
334 case RETURN:{
335 ReturnStatement();
336 break;
337 }
338 case CONTINUE:{
339 Continue();
340 break;
341 }
342 case BREAK:{
343 Break();
344 break;
345 }
346 case THROW:{
347 ThrowStatement();
348 break;
349 }
350 case TRY:{
351 TryStatement();
352 break;
353 }
354 default:
355 if (jj_2_11(3)) {
356 SwitchStatement();
357 } else if (jj_2_12(2147483647)) {
358 Lambda();
359 } else if (jj_2_13(2147483647)) {
360 ExpressionStatement();
361 } else {
362 switch (jj_nt.kind) {
363 case LCURLY:{
364 Block();
365 break;
366 }
367 default:
368 if (jj_2_14(2147483647) && (!getFeatures().isLexical())) {
369 Var();
370 } else {
371 jj_consume_token(-1);
372 throw new ParseException();
373 }
374 }
375 }
376 }
377 }
378
379 final public void Block() throws ParseException {
380 ASTBlock jjtn000 = new ASTBlock(JJTBLOCK);
381 boolean jjtc000 = true;
382 jjtree.openNodeScope(jjtn000);
383 jjtreeOpenNodeScope(jjtn000);
384 jjtn000.jjtSetFirstToken(getToken(1));
385 try {
386 jj_consume_token(LCURLY);
387 pushUnit(jjtn000);
388 label_5:
389 while (true) {
390 if (jj_2_15(1)) {
391 } else {
392 break label_5;
393 }
394 switch (jj_nt.kind) {
395 case PRAGMA:{
396 Pragma();
397 break;
398 }
399 default:
400 if (jj_2_16(1)) {
401 Statement();
402 } else {
403 jj_consume_token(-1);
404 throw new ParseException();
405 }
406 }
407 }
408 popUnit(jjtn000);
409 jj_consume_token(RCURLY);
410 } catch (Throwable jjte000) {
411 if (jjtc000) {
412 jjtree.clearNodeScope(jjtn000);
413 jjtc000 = false;
414 } else {
415 jjtree.popNode();
416 }
417 if (jjte000 instanceof ParseException) {
418 throw (ParseException)jjte000;
419 }
420 if (jjte000 instanceof RuntimeException) {
421 throw (RuntimeException)jjte000;
422 }
423 throw (Error)jjte000;
424 } finally {
425 if (jjtc000) {
426 jjtree.closeNodeScope(jjtn000, true);
427 if (jjtree.nodeCreated()) {
428 jjtreeCloseNodeScope(jjtn000);
429 }
430 jjtn000.jjtSetLastToken(getToken(0));
431 }
432 }
433 }
434
435 final public void FunctionStatement() throws ParseException {
436 ASTJexlLambda jjtn000 = new ASTJexlLambda(JJTJEXLLAMBDA);
437 boolean jjtc000 = true;
438 jjtree.openNodeScope(jjtn000);
439 jjtreeOpenNodeScope(jjtn000);
440 jjtn000.jjtSetFirstToken(getToken(1));
441 try {
442 jj_consume_token(FUNCTION);
443 DeclareFunction();
444 beginLambda(jjtn000);
445 Parameters();
446 if (jj_2_17(3)) {
447 Block();
448 } else if (jj_2_18(1)) {
449 Expression();
450 } else {
451 jj_consume_token(-1);
452 throw new ParseException();
453 }
454 jjtree.closeNodeScope(jjtn000, true);
455 jjtc000 = false;
456 if (jjtree.nodeCreated()) {
457 jjtreeCloseNodeScope(jjtn000);
458 }
459 jjtn000.jjtSetLastToken(getToken(0));
460 endLambda(jjtn000);
461 } catch (Throwable jjte000) {
462 if (jjtc000) {
463 jjtree.clearNodeScope(jjtn000);
464 jjtc000 = false;
465 } else {
466 jjtree.popNode();
467 }
468 if (jjte000 instanceof ParseException) {
469 throw (ParseException)jjte000;
470 }
471 if (jjte000 instanceof RuntimeException) {
472 throw (RuntimeException)jjte000;
473 }
474 throw (Error)jjte000;
475 } finally {
476 if (jjtc000) {
477 jjtree.closeNodeScope(jjtn000, true);
478 if (jjtree.nodeCreated()) {
479 jjtreeCloseNodeScope(jjtn000);
480 }
481 jjtn000.jjtSetLastToken(getToken(0));
482 }
483 }
484 }
485
486 final public void ExpressionStatement() throws ParseException {
487 Expression();
488 label_6:
489 while (true) {
490 if (jj_2_19(2) && (isAmbiguousStatement(SEMICOL))) {
491 } else {
492 break label_6;
493 }
494 ASTAmbiguous jjtn001 = new ASTAmbiguous(JJTAMBIGUOUS);
495 boolean jjtc001 = true;
496 jjtree.openNodeScope(jjtn001);
497 jjtreeOpenNodeScope(jjtn001);
498 jjtn001.jjtSetFirstToken(getToken(1));
499 try {
500 Expression();
501 } catch (Throwable jjte001) {
502 if (jjtc001) {
503 jjtree.clearNodeScope(jjtn001);
504 jjtc001 = false;
505 } else {
506 jjtree.popNode();
507 }
508 if (jjte001 instanceof ParseException) {
509 throw (ParseException)jjte001;
510 }
511 if (jjte001 instanceof RuntimeException) {
512 throw (RuntimeException)jjte001;
513 }
514 throw (Error)jjte001;
515 } finally {
516 if (jjtc001) {
517 jjtree.closeNodeScope(jjtn001, 1);
518 if (jjtree.nodeCreated()) {
519 jjtreeCloseNodeScope(jjtn001);
520 }
521 jjtn001.jjtSetLastToken(getToken(0));
522 }
523 }
524 }
525 switch (jj_nt.kind) {
526 case SEMICOL:{
527 jj_consume_token(SEMICOL);
528 break;
529 }
530 default:
531 ;
532 }
533 }
534
535 final public void IfStatement() throws ParseException {
536 ASTIfStatement jjtn000 = new ASTIfStatement(JJTIFSTATEMENT);
537 boolean jjtc000 = true;
538 jjtree.openNodeScope(jjtn000);
539 jjtreeOpenNodeScope(jjtn000);
540 jjtn000.jjtSetFirstToken(getToken(1));
541 try {
542 jj_consume_token(IF);
543 jj_consume_token(LPAREN);
544 Expression();
545 jj_consume_token(RPAREN);
546 switch (jj_nt.kind) {
547 case LCURLY:{
548 Block();
549 break;
550 }
551 default:
552 if (jj_2_20(1)) {
553 StatementSink();
554 } else {
555 jj_consume_token(-1);
556 throw new ParseException();
557 }
558 }
559 label_7:
560 while (true) {
561 if (jj_2_21(2)) {
562 } else {
563 break label_7;
564 }
565 jj_consume_token(ELSE);
566 jj_consume_token(IF);
567 jj_consume_token(LPAREN);
568 Expression();
569 jj_consume_token(RPAREN);
570 switch (jj_nt.kind) {
571 case LCURLY:{
572 Block();
573 break;
574 }
575 default:
576 if (jj_2_22(1)) {
577 StatementSink();
578 } else {
579 jj_consume_token(-1);
580 throw new ParseException();
581 }
582 }
583 }
584 switch (jj_nt.kind) {
585 case ELSE:{
586 jj_consume_token(ELSE);
587 switch (jj_nt.kind) {
588 case LCURLY:{
589 Block();
590 break;
591 }
592 default:
593 if (jj_2_23(1)) {
594 StatementSink();
595 } else {
596 jj_consume_token(-1);
597 throw new ParseException();
598 }
599 }
600 break;
601 }
602 default:
603 ;
604 }
605 } catch (Throwable jjte000) {
606 if (jjtc000) {
607 jjtree.clearNodeScope(jjtn000);
608 jjtc000 = false;
609 } else {
610 jjtree.popNode();
611 }
612 if (jjte000 instanceof ParseException) {
613 throw (ParseException)jjte000;
614 }
615 if (jjte000 instanceof RuntimeException) {
616 throw (RuntimeException)jjte000;
617 }
618 throw (Error)jjte000;
619 } finally {
620 if (jjtc000) {
621 jjtree.closeNodeScope(jjtn000, true);
622 if (jjtree.nodeCreated()) {
623 jjtreeCloseNodeScope(jjtn000);
624 }
625 jjtn000.jjtSetLastToken(getToken(0));
626 }
627 }
628 }
629
630 final public void TryStatement() throws ParseException {
631 ASTTryStatement jjtn000 = new ASTTryStatement(JJTTRYSTATEMENT);
632 boolean jjtc000 = true;
633 jjtree.openNodeScope(jjtn000);
634 jjtreeOpenNodeScope(jjtn000);
635 jjtn000.jjtSetFirstToken(getToken(1));
636 try {
637 jj_consume_token(TRY);
638 switch (jj_nt.kind) {
639 case LPAREN:{
640 TryResources();
641 break;
642 }
643 case LCURLY:{
644 Block();
645 break;
646 }
647 default:
648 jj_consume_token(-1);
649 throw new ParseException();
650 }
651 switch (jj_nt.kind) {
652 case CATCH:{
653 jj_consume_token(CATCH);
654 pushUnit(jjtn000);
655 jj_consume_token(LPAREN);
656 InlineVar();
657 jj_consume_token(RPAREN);
658 Block();
659 jjtn000.catchClause(); popUnit(jjtn000);
660 break;
661 }
662 default:
663 ;
664 }
665 switch (jj_nt.kind) {
666 case FINALLY:{
667 jj_consume_token(FINALLY);
668 Block();
669 jjtn000.finallyClause();
670 break;
671 }
672 default:
673 ;
674 }
675 } catch (Throwable jjte000) {
676 if (jjtc000) {
677 jjtree.clearNodeScope(jjtn000);
678 jjtc000 = false;
679 } else {
680 jjtree.popNode();
681 }
682 if (jjte000 instanceof ParseException) {
683 throw (ParseException)jjte000;
684 }
685 if (jjte000 instanceof RuntimeException) {
686 throw (RuntimeException)jjte000;
687 }
688 throw (Error)jjte000;
689 } finally {
690 if (jjtc000) {
691 jjtree.closeNodeScope(jjtn000, true);
692 if (jjtree.nodeCreated()) {
693 jjtreeCloseNodeScope(jjtn000);
694 }
695 jjtn000.jjtSetLastToken(getToken(0));
696 }
697 }
698 }
699
700 final public void TryResources() throws ParseException {
701 ASTTryResources jjtn000 = new ASTTryResources(JJTTRYRESOURCES);
702 boolean jjtc000 = true;
703 jjtree.openNodeScope(jjtn000);
704 jjtreeOpenNodeScope(jjtn000);
705 jjtn000.jjtSetFirstToken(getToken(1));
706 try {
707 pushUnit(jjtn000);
708 jj_consume_token(LPAREN);
709 TryResource();
710 label_8:
711 while (true) {
712 if (jj_2_24(2)) {
713 } else {
714 break label_8;
715 }
716 jj_consume_token(SEMICOL);
717 TryResource();
718 }
719 switch (jj_nt.kind) {
720 case SEMICOL:{
721 jj_consume_token(SEMICOL);
722 break;
723 }
724 default:
725 ;
726 }
727 jj_consume_token(RPAREN);
728 Block();
729 jjtree.closeNodeScope(jjtn000, true);
730 jjtc000 = false;
731 if (jjtree.nodeCreated()) {
732 jjtreeCloseNodeScope(jjtn000);
733 }
734 jjtn000.jjtSetLastToken(getToken(0));
735 popUnit(jjtn000);
736 } catch (Throwable jjte000) {
737 if (jjtc000) {
738 jjtree.clearNodeScope(jjtn000);
739 jjtc000 = false;
740 } else {
741 jjtree.popNode();
742 }
743 if (jjte000 instanceof ParseException) {
744 throw (ParseException)jjte000;
745 }
746 if (jjte000 instanceof RuntimeException) {
747 throw (RuntimeException)jjte000;
748 }
749 throw (Error)jjte000;
750 } finally {
751 if (jjtc000) {
752 jjtree.closeNodeScope(jjtn000, true);
753 if (jjtree.nodeCreated()) {
754 jjtreeCloseNodeScope(jjtn000);
755 }
756 jjtn000.jjtSetLastToken(getToken(0));
757 }
758 }
759 }
760
761 final public void TryResource() throws ParseException {
762 if (jj_2_25(2)) {
763 Var();
764 } else {
765 switch (jj_nt.kind) {
766 case IDENTIFIER:
767 case REGISTER:{
768 Identifier(true);
769 break;
770 }
771 default:
772 jj_consume_token(-1);
773 throw new ParseException();
774 }
775 }
776 }
777
778 final public void WhileStatement() throws ParseException {
779 ASTWhileStatement jjtn000 = new ASTWhileStatement(JJTWHILESTATEMENT);
780 boolean jjtc000 = true;
781 jjtree.openNodeScope(jjtn000);
782 jjtreeOpenNodeScope(jjtn000);
783 jjtn000.jjtSetFirstToken(getToken(1));
784 try {
785 jj_consume_token(WHILE);
786 jj_consume_token(LPAREN);
787 Expression();
788 jj_consume_token(RPAREN);
789 loopCount.incrementAndGet();
790 switch (jj_nt.kind) {
791 case LCURLY:{
792 Block();
793 break;
794 }
795 default:
796 if (jj_2_26(1)) {
797 StatementSink();
798 } else {
799 jj_consume_token(-1);
800 throw new ParseException();
801 }
802 }
803 jjtree.closeNodeScope(jjtn000, true);
804 jjtc000 = false;
805 if (jjtree.nodeCreated()) {
806 jjtreeCloseNodeScope(jjtn000);
807 }
808 jjtn000.jjtSetLastToken(getToken(0));
809 loopCount.decrementAndGet();
810 } catch (Throwable jjte000) {
811 if (jjtc000) {
812 jjtree.clearNodeScope(jjtn000);
813 jjtc000 = false;
814 } else {
815 jjtree.popNode();
816 }
817 if (jjte000 instanceof ParseException) {
818 throw (ParseException)jjte000;
819 }
820 if (jjte000 instanceof RuntimeException) {
821 throw (RuntimeException)jjte000;
822 }
823 throw (Error)jjte000;
824 } finally {
825 if (jjtc000) {
826 jjtree.closeNodeScope(jjtn000, true);
827 if (jjtree.nodeCreated()) {
828 jjtreeCloseNodeScope(jjtn000);
829 }
830 jjtn000.jjtSetLastToken(getToken(0));
831 }
832 }
833 }
834
835 final public void DoWhileStatement() throws ParseException {
836 ASTDoWhileStatement jjtn000 = new ASTDoWhileStatement(JJTDOWHILESTATEMENT);
837 boolean jjtc000 = true;
838 jjtree.openNodeScope(jjtn000);
839 jjtreeOpenNodeScope(jjtn000);
840 jjtn000.jjtSetFirstToken(getToken(1));
841 try {
842 jj_consume_token(DO);
843 loopCount.incrementAndGet();
844 switch (jj_nt.kind) {
845 case LCURLY:{
846 Block();
847 break;
848 }
849 default:
850 if (jj_2_27(1)) {
851 StatementSink();
852 } else {
853 jj_consume_token(-1);
854 throw new ParseException();
855 }
856 }
857 jj_consume_token(WHILE);
858 jj_consume_token(LPAREN);
859 Expression();
860 jj_consume_token(RPAREN);
861 jjtree.closeNodeScope(jjtn000, true);
862 jjtc000 = false;
863 if (jjtree.nodeCreated()) {
864 jjtreeCloseNodeScope(jjtn000);
865 }
866 jjtn000.jjtSetLastToken(getToken(0));
867 loopCount.decrementAndGet();
868 } catch (Throwable jjte000) {
869 if (jjtc000) {
870 jjtree.clearNodeScope(jjtn000);
871 jjtc000 = false;
872 } else {
873 jjtree.popNode();
874 }
875 if (jjte000 instanceof ParseException) {
876 throw (ParseException)jjte000;
877 }
878 if (jjte000 instanceof RuntimeException) {
879 throw (RuntimeException)jjte000;
880 }
881 throw (Error)jjte000;
882 } finally {
883 if (jjtc000) {
884 jjtree.closeNodeScope(jjtn000, true);
885 if (jjtree.nodeCreated()) {
886 jjtreeCloseNodeScope(jjtn000);
887 }
888 jjtn000.jjtSetLastToken(getToken(0));
889 }
890 }
891 }
892
893 final public void ReturnStatement() throws ParseException {
894 ASTReturnStatement jjtn000 = new ASTReturnStatement(JJTRETURNSTATEMENT);
895 boolean jjtc000 = true;
896 jjtree.openNodeScope(jjtn000);
897 jjtreeOpenNodeScope(jjtn000);
898 jjtn000.jjtSetFirstToken(getToken(1));this.autoSemicolon = false;
899 try {
900 jj_consume_token(RETURN);
901 if (jj_2_28(2)) {
902 ExpressionStatement();
903 } else {
904 ;
905 }
906 jjtree.closeNodeScope(jjtn000, true);
907 jjtc000 = false;
908 if (jjtree.nodeCreated()) {
909 jjtreeCloseNodeScope(jjtn000);
910 }
911 jjtn000.jjtSetLastToken(getToken(0));
912 this.autoSemicolon = true;
913 } catch (Throwable jjte000) {
914 if (jjtc000) {
915 jjtree.clearNodeScope(jjtn000);
916 jjtc000 = false;
917 } else {
918 jjtree.popNode();
919 }
920 if (jjte000 instanceof ParseException) {
921 throw (ParseException)jjte000;
922 }
923 if (jjte000 instanceof RuntimeException) {
924 throw (RuntimeException)jjte000;
925 }
926 throw (Error)jjte000;
927 } finally {
928 if (jjtc000) {
929 jjtree.closeNodeScope(jjtn000, true);
930 if (jjtree.nodeCreated()) {
931 jjtreeCloseNodeScope(jjtn000);
932 }
933 jjtn000.jjtSetLastToken(getToken(0));
934 }
935 }
936 }
937
938 final public void ThrowStatement() throws ParseException {
939 ASTThrowStatement jjtn000 = new ASTThrowStatement(JJTTHROWSTATEMENT);
940 boolean jjtc000 = true;
941 jjtree.openNodeScope(jjtn000);
942 jjtreeOpenNodeScope(jjtn000);
943 jjtn000.jjtSetFirstToken(getToken(1));this.autoSemicolon = false;
944 try {
945 jj_consume_token(THROW);
946 if (jj_2_29(2)) {
947 ExpressionStatement();
948 } else {
949 ;
950 }
951 jjtree.closeNodeScope(jjtn000, true);
952 jjtc000 = false;
953 if (jjtree.nodeCreated()) {
954 jjtreeCloseNodeScope(jjtn000);
955 }
956 jjtn000.jjtSetLastToken(getToken(0));
957 this.autoSemicolon = true;
958 } catch (Throwable jjte000) {
959 if (jjtc000) {
960 jjtree.clearNodeScope(jjtn000);
961 jjtc000 = false;
962 } else {
963 jjtree.popNode();
964 }
965 if (jjte000 instanceof ParseException) {
966 throw (ParseException)jjte000;
967 }
968 if (jjte000 instanceof RuntimeException) {
969 throw (RuntimeException)jjte000;
970 }
971 throw (Error)jjte000;
972 } finally {
973 if (jjtc000) {
974 jjtree.closeNodeScope(jjtn000, true);
975 if (jjtree.nodeCreated()) {
976 jjtreeCloseNodeScope(jjtn000);
977 }
978 jjtn000.jjtSetLastToken(getToken(0));
979 }
980 }
981 }
982
983 final public void Continue() throws ParseException {
984 ASTContinue jjtn000 = new ASTContinue(JJTCONTINUE);
985 boolean jjtc000 = true;
986 jjtree.openNodeScope(jjtn000);
987 jjtreeOpenNodeScope(jjtn000);
988 jjtn000.jjtSetFirstToken(getToken(1));Token t;
989 try {
990 t = jj_consume_token(CONTINUE);
991 jjtree.closeNodeScope(jjtn000, true);
992 jjtc000 = false;
993 if (jjtree.nodeCreated()) {
994 jjtreeCloseNodeScope(jjtn000);
995 }
996 jjtn000.jjtSetLastToken(getToken(0));
997 if (loopCount.get() == 0) { throwParsingException(t); }
998 } finally {
999 if (jjtc000) {
1000 jjtree.closeNodeScope(jjtn000, true);
1001 if (jjtree.nodeCreated()) {
1002 jjtreeCloseNodeScope(jjtn000);
1003 }
1004 jjtn000.jjtSetLastToken(getToken(0));
1005 }
1006 }
1007 }
1008
1009 final public void Break() throws ParseException {
1010 ASTBreak jjtn000 = new ASTBreak(JJTBREAK);
1011 boolean jjtc000 = true;
1012 jjtree.openNodeScope(jjtn000);
1013 jjtreeOpenNodeScope(jjtn000);
1014 jjtn000.jjtSetFirstToken(getToken(1));Token t;
1015 try {
1016 t = jj_consume_token(BREAK);
1017 jjtree.closeNodeScope(jjtn000, true);
1018 jjtc000 = false;
1019 if (jjtree.nodeCreated()) {
1020 jjtreeCloseNodeScope(jjtn000);
1021 }
1022 jjtn000.jjtSetLastToken(getToken(0));
1023 if (loopCount.get() == 0) { throwParsingException(t); }
1024 } finally {
1025 if (jjtc000) {
1026 jjtree.closeNodeScope(jjtn000, true);
1027 if (jjtree.nodeCreated()) {
1028 jjtreeCloseNodeScope(jjtn000);
1029 }
1030 jjtn000.jjtSetLastToken(getToken(0));
1031 }
1032 }
1033 }
1034
1035 final public void ForeachStatement() throws ParseException {
1036 ASTForeachStatement jjtn000 = new ASTForeachStatement(JJTFOREACHSTATEMENT);
1037 boolean jjtc000 = true;
1038 jjtree.openNodeScope(jjtn000);
1039 jjtreeOpenNodeScope(jjtn000);
1040 jjtn000.jjtSetFirstToken(getToken(1));int loopForm = 0;
1041 try {
1042 pushUnit(jjtn000);
1043 jj_consume_token(FOR);
1044 jj_consume_token(LPAREN);
1045 if (jj_2_34(3)) {
1046 InlineVar();
1047 jj_consume_token(COLON);
1048 Expression();
1049 loopForm = 0;
1050 } else if (jj_2_35(1)) {
1051 if (jj_2_31(1)) {
1052 switch (jj_nt.kind) {
1053 case VAR:
1054 case LET:
1055 case CONST:{
1056 Var();
1057 break;
1058 }
1059 default:
1060 if (jj_2_30(1)) {
1061 Expression();
1062 } else {
1063 jj_consume_token(-1);
1064 throw new ParseException();
1065 }
1066 }
1067 loopForm = 1;
1068 } else {
1069 ;
1070 }
1071 jj_consume_token(SEMICOL);
1072 if (jj_2_32(1)) {
1073 Expression();
1074 loopForm |= 2;
1075 } else {
1076 ;
1077 }
1078 jj_consume_token(SEMICOL);
1079 if (jj_2_33(1)) {
1080 Expression();
1081 loopForm |= 4;
1082 } else {
1083 ;
1084 }
1085 loopForm |= 8;
1086 } else {
1087 jj_consume_token(-1);
1088 throw new ParseException();
1089 }
1090 jj_consume_token(RPAREN);
1091 loopCount.incrementAndGet();
1092 switch (jj_nt.kind) {
1093 case LCURLY:{
1094 Block();
1095 break;
1096 }
1097 default:
1098 if (jj_2_36(1)) {
1099 StatementSink();
1100 } else {
1101 jj_consume_token(-1);
1102 throw new ParseException();
1103 }
1104 }
1105 jjtree.closeNodeScope(jjtn000, true);
1106 jjtc000 = false;
1107 if (jjtree.nodeCreated()) {
1108 jjtreeCloseNodeScope(jjtn000);
1109 }
1110 jjtn000.jjtSetLastToken(getToken(0));
1111 loopCount.decrementAndGet();
1112 jjtn000.setLoopForm(loopForm);
1113 popUnit(jjtn000);
1114 } catch (Throwable jjte000) {
1115 if (jjtc000) {
1116 jjtree.clearNodeScope(jjtn000);
1117 jjtc000 = false;
1118 } else {
1119 jjtree.popNode();
1120 }
1121 if (jjte000 instanceof ParseException) {
1122 throw (ParseException)jjte000;
1123 }
1124 if (jjte000 instanceof RuntimeException) {
1125 throw (RuntimeException)jjte000;
1126 }
1127 throw (Error)jjte000;
1128 } finally {
1129 if (jjtc000) {
1130 jjtree.closeNodeScope(jjtn000, true);
1131 if (jjtree.nodeCreated()) {
1132 jjtreeCloseNodeScope(jjtn000);
1133 }
1134 jjtn000.jjtSetLastToken(getToken(0));
1135 }
1136 }
1137 }
1138
1139 final public void InlineVar() throws ParseException {
1140 ASTReference jjtn000 = new ASTReference(JJTREFERENCE);
1141 boolean jjtc000 = true;
1142 jjtree.openNodeScope(jjtn000);
1143 jjtreeOpenNodeScope(jjtn000);
1144 jjtn000.jjtSetFirstToken(getToken(1));
1145 try {
1146 switch (jj_nt.kind) {
1147 case VAR:{
1148 jj_consume_token(VAR);
1149 DeclareVar(false, false);
1150 break;
1151 }
1152 case LET:{
1153 jj_consume_token(LET);
1154 DeclareVar(true, false);
1155 break;
1156 }
1157 case CONST:{
1158 jj_consume_token(CONST);
1159 DeclareVar(true, true);
1160 break;
1161 }
1162 case IDENTIFIER:
1163 case REGISTER:{
1164 Identifier(true);
1165 break;
1166 }
1167 default:
1168 jj_consume_token(-1);
1169 throw new ParseException();
1170 }
1171 } catch (Throwable jjte000) {
1172 if (jjtc000) {
1173 jjtree.clearNodeScope(jjtn000);
1174 jjtc000 = false;
1175 } else {
1176 jjtree.popNode();
1177 }
1178 if (jjte000 instanceof ParseException) {
1179 throw (ParseException)jjte000;
1180 }
1181 if (jjte000 instanceof RuntimeException) {
1182 throw (RuntimeException)jjte000;
1183 }
1184 throw (Error)jjte000;
1185 } finally {
1186 if (jjtc000) {
1187 jjtree.closeNodeScope(jjtn000, true);
1188 if (jjtree.nodeCreated()) {
1189 jjtreeCloseNodeScope(jjtn000);
1190 }
1191 jjtn000.jjtSetLastToken(getToken(0));
1192 }
1193 }
1194 }
1195
1196 final public void Var() throws ParseException {
1197 switch (jj_nt.kind) {
1198 case VAR:{
1199 ASTDefineVars jjtn001 = new ASTDefineVars(JJTDEFINEVARS);
1200 boolean jjtc001 = true;
1201 jjtree.openNodeScope(jjtn001);
1202 jjtreeOpenNodeScope(jjtn001);
1203 jjtn001.jjtSetFirstToken(getToken(1));
1204 try {
1205 jj_consume_token(VAR);
1206 DefineVar();
1207 label_9:
1208 while (true) {
1209 switch (jj_nt.kind) {
1210 case COMMA:{
1211 break;
1212 }
1213 default:
1214 break label_9;
1215 }
1216 jj_consume_token(COMMA);
1217 DefineVar();
1218 }
1219 } catch (Throwable jjte001) {
1220 if (jjtc001) {
1221 jjtree.clearNodeScope(jjtn001);
1222 jjtc001 = false;
1223 } else {
1224 jjtree.popNode();
1225 }
1226 if (jjte001 instanceof ParseException) {
1227 throw (ParseException)jjte001;
1228 }
1229 if (jjte001 instanceof RuntimeException) {
1230 throw (RuntimeException)jjte001;
1231 }
1232 throw (Error)jjte001;
1233 } finally {
1234 if (jjtc001) {
1235 jjtree.closeNodeScope(jjtn001, jjtree.nodeArity() > 1);
1236 if (jjtree.nodeCreated()) {
1237 jjtreeCloseNodeScope(jjtn001);
1238 }
1239 jjtn001.jjtSetLastToken(getToken(0));
1240 }
1241 }
1242 break;
1243 }
1244 case LET:{
1245 ASTDefineVars jjtn002 = new ASTDefineVars(JJTDEFINEVARS);
1246 boolean jjtc002 = true;
1247 jjtree.openNodeScope(jjtn002);
1248 jjtreeOpenNodeScope(jjtn002);
1249 jjtn002.jjtSetFirstToken(getToken(1));
1250 try {
1251 jj_consume_token(LET);
1252 DefineLet();
1253 label_10:
1254 while (true) {
1255 switch (jj_nt.kind) {
1256 case COMMA:{
1257 break;
1258 }
1259 default:
1260 break label_10;
1261 }
1262 jj_consume_token(COMMA);
1263 DefineLet();
1264 }
1265 } catch (Throwable jjte002) {
1266 if (jjtc002) {
1267 jjtree.clearNodeScope(jjtn002);
1268 jjtc002 = false;
1269 } else {
1270 jjtree.popNode();
1271 }
1272 if (jjte002 instanceof ParseException) {
1273 throw (ParseException)jjte002;
1274 }
1275 if (jjte002 instanceof RuntimeException) {
1276 throw (RuntimeException)jjte002;
1277 }
1278 throw (Error)jjte002;
1279 } finally {
1280 if (jjtc002) {
1281 jjtree.closeNodeScope(jjtn002, jjtree.nodeArity() > 1);
1282 if (jjtree.nodeCreated()) {
1283 jjtreeCloseNodeScope(jjtn002);
1284 }
1285 jjtn002.jjtSetLastToken(getToken(0));
1286 }
1287 }
1288 break;
1289 }
1290 case CONST:{
1291 ASTDefineVars jjtn003 = new ASTDefineVars(JJTDEFINEVARS);
1292 boolean jjtc003 = true;
1293 jjtree.openNodeScope(jjtn003);
1294 jjtreeOpenNodeScope(jjtn003);
1295 jjtn003.jjtSetFirstToken(getToken(1));
1296 try {
1297 jj_consume_token(CONST);
1298 DefineConst();
1299 label_11:
1300 while (true) {
1301 switch (jj_nt.kind) {
1302 case COMMA:{
1303 break;
1304 }
1305 default:
1306 break label_11;
1307 }
1308 jj_consume_token(COMMA);
1309 DefineConst();
1310 }
1311 } catch (Throwable jjte003) {
1312 if (jjtc003) {
1313 jjtree.clearNodeScope(jjtn003);
1314 jjtc003 = false;
1315 } else {
1316 jjtree.popNode();
1317 }
1318 if (jjte003 instanceof ParseException) {
1319 throw (ParseException)jjte003;
1320 }
1321 if (jjte003 instanceof RuntimeException) {
1322 throw (RuntimeException)jjte003;
1323 }
1324 throw (Error)jjte003;
1325 } finally {
1326 if (jjtc003) {
1327 jjtree.closeNodeScope(jjtn003, jjtree.nodeArity() > 1);
1328 if (jjtree.nodeCreated()) {
1329 jjtreeCloseNodeScope(jjtn003);
1330 }
1331 jjtn003.jjtSetLastToken(getToken(0));
1332 }
1333 }
1334 break;
1335 }
1336 default:
1337 jj_consume_token(-1);
1338 throw new ParseException();
1339 }
1340 }
1341
1342 final public void DefineVar() throws ParseException {
1343 DeclareVar(false, false);
1344 switch (jj_nt.kind) {
1345 case assign:{
1346 jj_consume_token(assign);
1347 ASTAssignment jjtn001 = new ASTAssignment(JJTASSIGNMENT);
1348 boolean jjtc001 = true;
1349 jjtree.openNodeScope(jjtn001);
1350 jjtreeOpenNodeScope(jjtn001);
1351 jjtn001.jjtSetFirstToken(getToken(1));
1352 try {
1353 Expression();
1354 } catch (Throwable jjte001) {
1355 if (jjtc001) {
1356 jjtree.clearNodeScope(jjtn001);
1357 jjtc001 = false;
1358 } else {
1359 jjtree.popNode();
1360 }
1361 if (jjte001 instanceof ParseException) {
1362 throw (ParseException)jjte001;
1363 }
1364 if (jjte001 instanceof RuntimeException) {
1365 throw (RuntimeException)jjte001;
1366 }
1367 throw (Error)jjte001;
1368 } finally {
1369 if (jjtc001) {
1370 jjtree.closeNodeScope(jjtn001, 2);
1371 if (jjtree.nodeCreated()) {
1372 jjtreeCloseNodeScope(jjtn001);
1373 }
1374 jjtn001.jjtSetLastToken(getToken(0));
1375 }
1376 }
1377 break;
1378 }
1379 default:
1380 ;
1381 }
1382 }
1383
1384 final public void DefineLet() throws ParseException {
1385 DeclareVar(true, false);
1386 switch (jj_nt.kind) {
1387 case assign:{
1388 jj_consume_token(assign);
1389 ASTAssignment jjtn001 = new ASTAssignment(JJTASSIGNMENT);
1390 boolean jjtc001 = true;
1391 jjtree.openNodeScope(jjtn001);
1392 jjtreeOpenNodeScope(jjtn001);
1393 jjtn001.jjtSetFirstToken(getToken(1));
1394 try {
1395 Expression();
1396 } catch (Throwable jjte001) {
1397 if (jjtc001) {
1398 jjtree.clearNodeScope(jjtn001);
1399 jjtc001 = false;
1400 } else {
1401 jjtree.popNode();
1402 }
1403 if (jjte001 instanceof ParseException) {
1404 throw (ParseException)jjte001;
1405 }
1406 if (jjte001 instanceof RuntimeException) {
1407 throw (RuntimeException)jjte001;
1408 }
1409 throw (Error)jjte001;
1410 } finally {
1411 if (jjtc001) {
1412 jjtree.closeNodeScope(jjtn001, 2);
1413 if (jjtree.nodeCreated()) {
1414 jjtreeCloseNodeScope(jjtn001);
1415 }
1416 jjtn001.jjtSetLastToken(getToken(0));
1417 }
1418 }
1419 break;
1420 }
1421 default:
1422 ;
1423 }
1424 }
1425
1426 final public void DefineConst() throws ParseException {
1427 DeclareVar(true, true);
1428 jj_consume_token(assign);
1429 ASTAssignment jjtn001 = new ASTAssignment(JJTASSIGNMENT);
1430 boolean jjtc001 = true;
1431 jjtree.openNodeScope(jjtn001);
1432 jjtreeOpenNodeScope(jjtn001);
1433 jjtn001.jjtSetFirstToken(getToken(1));
1434 try {
1435 Expression();
1436 } catch (Throwable jjte001) {
1437 if (jjtc001) {
1438 jjtree.clearNodeScope(jjtn001);
1439 jjtc001 = false;
1440 } else {
1441 jjtree.popNode();
1442 }
1443 if (jjte001 instanceof ParseException) {
1444 throw (ParseException)jjte001;
1445 }
1446 if (jjte001 instanceof RuntimeException) {
1447 throw (RuntimeException)jjte001;
1448 }
1449 throw (Error)jjte001;
1450 } finally {
1451 if (jjtc001) {
1452 jjtree.closeNodeScope(jjtn001, 2);
1453 if (jjtree.nodeCreated()) {
1454 jjtreeCloseNodeScope(jjtn001);
1455 }
1456 jjtn001.jjtSetLastToken(getToken(0));
1457 }
1458 }
1459 }
1460
1461 final public void DeclareVar(boolean lexical, boolean constant) throws ParseException {
1462 ASTVar jjtn000 = new ASTVar(JJTVAR);
1463 boolean jjtc000 = true;
1464 jjtree.openNodeScope(jjtn000);
1465 jjtreeOpenNodeScope(jjtn000);
1466 jjtn000.jjtSetFirstToken(getToken(1));Token t;
1467 try {
1468 t = jj_consume_token(IDENTIFIER);
1469 jjtree.closeNodeScope(jjtn000, true);
1470 jjtc000 = false;
1471 if (jjtree.nodeCreated()) {
1472 jjtreeCloseNodeScope(jjtn000);
1473 }
1474 jjtn000.jjtSetLastToken(getToken(0));
1475 declareVariable(jjtn000, t, lexical, constant);
1476 } finally {
1477 if (jjtc000) {
1478 jjtree.closeNodeScope(jjtn000, true);
1479 if (jjtree.nodeCreated()) {
1480 jjtreeCloseNodeScope(jjtn000);
1481 }
1482 jjtn000.jjtSetLastToken(getToken(0));
1483 }
1484 }
1485 }
1486
1487 final public void DeclareFunction() throws ParseException {
1488 ASTVar jjtn000 = new ASTVar(JJTVAR);
1489 boolean jjtc000 = true;
1490 jjtree.openNodeScope(jjtn000);
1491 jjtreeOpenNodeScope(jjtn000);
1492 jjtn000.jjtSetFirstToken(getToken(1));Token t;
1493 try {
1494 t = jj_consume_token(IDENTIFIER);
1495 jjtree.closeNodeScope(jjtn000, true);
1496 jjtc000 = false;
1497 if (jjtree.nodeCreated()) {
1498 jjtreeCloseNodeScope(jjtn000);
1499 }
1500 jjtn000.jjtSetLastToken(getToken(0));
1501 declareFunction(jjtn000, t);
1502 } finally {
1503 if (jjtc000) {
1504 jjtree.closeNodeScope(jjtn000, true);
1505 if (jjtree.nodeCreated()) {
1506 jjtreeCloseNodeScope(jjtn000);
1507 }
1508 jjtn000.jjtSetLastToken(getToken(0));
1509 }
1510 }
1511 }
1512
1513 final public void SwitchStatement() throws ParseException {
1514 ASTSwitchStatement jjtn000 = new ASTSwitchStatement(JJTSWITCHSTATEMENT);
1515 boolean jjtc000 = true;
1516 jjtree.openNodeScope(jjtn000);
1517 jjtreeOpenNodeScope(jjtn000);
1518 jjtn000.jjtSetFirstToken(getToken(1));ASTSwitchStatement.Helper helper = new ASTSwitchStatement.Helper();
1519 SwitchSet cases = switchSet();
1520 try {
1521 jj_consume_token(SWITCH);
1522 jj_consume_token(LPAREN);
1523 Expression();
1524 jj_consume_token(RPAREN);
1525 jj_consume_token(LCURLY);
1526 if (jj_2_37(2147483647)) {
1527 label_12:
1528 while (true) {
1529 switch (jj_nt.kind) {
1530 case CASE:
1531 case CASE_DEFAULT:{
1532 break;
1533 }
1534 default:
1535 break label_12;
1536 }
1537 SwitchStatementCase(cases);
1538 helper.defineCase(cases);
1539 }
1540 } else {
1541 jjtn000.isStatement = false; pushLoop();
1542 label_13:
1543 while (true) {
1544 switch (jj_nt.kind) {
1545 case CASE:
1546 case CASE_DEFAULT:{
1547 break;
1548 }
1549 default:
1550 break label_13;
1551 }
1552 SwitchExpressionCase(cases);
1553 helper.defineCase(cases);
1554 }
1555 }
1556 popLoop();
1557 jj_consume_token(RCURLY);
1558 jjtree.closeNodeScope(jjtn000, true);
1559 jjtc000 = false;
1560 if (jjtree.nodeCreated()) {
1561 jjtreeCloseNodeScope(jjtn000);
1562 }
1563 jjtn000.jjtSetLastToken(getToken(0));
1564 helper.defineSwitch(jjtn000);
1565 } catch (Throwable jjte000) {
1566 if (jjtc000) {
1567 jjtree.clearNodeScope(jjtn000);
1568 jjtc000 = false;
1569 } else {
1570 jjtree.popNode();
1571 }
1572 if (jjte000 instanceof ParseException) {
1573 throw (ParseException)jjte000;
1574 }
1575 if (jjte000 instanceof RuntimeException) {
1576 throw (RuntimeException)jjte000;
1577 }
1578 throw (Error)jjte000;
1579 } finally {
1580 if (jjtc000) {
1581 jjtree.closeNodeScope(jjtn000, true);
1582 if (jjtree.nodeCreated()) {
1583 jjtreeCloseNodeScope(jjtn000);
1584 }
1585 jjtn000.jjtSetLastToken(getToken(0));
1586 }
1587 }
1588 }
1589
1590 final public void SwitchStatementLookahead() throws ParseException {
1591 switch (jj_nt.kind) {
1592 case CASE:{
1593 jj_consume_token(CASE);
1594 constLiteral();
1595 jj_consume_token(COLON);
1596 break;
1597 }
1598 case CASE_DEFAULT:{
1599 jj_consume_token(CASE_DEFAULT);
1600 jj_consume_token(COLON);
1601 break;
1602 }
1603 default:
1604 jj_consume_token(-1);
1605 throw new ParseException();
1606 }
1607 }
1608
1609 final public void SwitchStatementCase(SwitchSet cases) throws ParseException {
1610 ASTCaseStatement jjtn000 = new ASTCaseStatement(JJTCASESTATEMENT);
1611 boolean jjtc000 = true;
1612 jjtree.openNodeScope(jjtn000);
1613 jjtreeOpenNodeScope(jjtn000);
1614 jjtn000.jjtSetFirstToken(getToken(1));Object constant;
1615 List<Object> constants;
1616 loopCount.incrementAndGet();
1617 try {
1618 switch (jj_nt.kind) {
1619 case CASE:{
1620 label_14:
1621 while (true) {
1622 jj_consume_token(CASE);
1623 constant = constLiteral();
1624 jj_consume_token(COLON);
1625 constants = Collections.singletonList(constant); jjtn000.setValues(constants); cases.addAll(constants);
1626 if (jj_2_38(2)) {
1627 } else {
1628 break label_14;
1629 }
1630 }
1631 break;
1632 }
1633 case CASE_DEFAULT:{
1634 jj_consume_token(CASE_DEFAULT);
1635 jj_consume_token(COLON);
1636 break;
1637 }
1638 default:
1639 jj_consume_token(-1);
1640 throw new ParseException();
1641 }
1642 if (jj_2_42(1)) {
1643 if (jj_2_40(2147483647)) {
1644 Block();
1645 } else if (jj_2_41(1)) {
1646 label_15:
1647 while (true) {
1648 StatementSink();
1649 if (jj_2_39(1)) {
1650 } else {
1651 break label_15;
1652 }
1653 }
1654 } else {
1655 jj_consume_token(-1);
1656 throw new ParseException();
1657 }
1658 } else {
1659 ;
1660 }
1661 jjtree.closeNodeScope(jjtn000, true);
1662 jjtc000 = false;
1663 if (jjtree.nodeCreated()) {
1664 jjtreeCloseNodeScope(jjtn000);
1665 }
1666 jjtn000.jjtSetLastToken(getToken(0));
1667 loopCount.decrementAndGet();
1668 } catch (Throwable jjte000) {
1669 if (jjtc000) {
1670 jjtree.clearNodeScope(jjtn000);
1671 jjtc000 = false;
1672 } else {
1673 jjtree.popNode();
1674 }
1675 if (jjte000 instanceof ParseException) {
1676 throw (ParseException)jjte000;
1677 }
1678 if (jjte000 instanceof RuntimeException) {
1679 throw (RuntimeException)jjte000;
1680 }
1681 throw (Error)jjte000;
1682 } finally {
1683 if (jjtc000) {
1684 jjtree.closeNodeScope(jjtn000, true);
1685 if (jjtree.nodeCreated()) {
1686 jjtreeCloseNodeScope(jjtn000);
1687 }
1688 jjtn000.jjtSetLastToken(getToken(0));
1689 }
1690 }
1691 }
1692
1693 final public void SwitchExpression() throws ParseException {
1694 ASTSwitchExpression jjtn000 = new ASTSwitchExpression(JJTSWITCHEXPRESSION);
1695 boolean jjtc000 = true;
1696 jjtree.openNodeScope(jjtn000);
1697 jjtreeOpenNodeScope(jjtn000);
1698 jjtn000.jjtSetFirstToken(getToken(1));ASTSwitchStatement.Helper helper = new ASTSwitchStatement.Helper();
1699 SwitchSet cases = switchSet();
1700 pushLoop();
1701 try {
1702 jj_consume_token(SWITCH);
1703 jj_consume_token(LPAREN);
1704 Expression();
1705 jj_consume_token(RPAREN);
1706 jj_consume_token(LCURLY);
1707 label_16:
1708 while (true) {
1709 switch (jj_nt.kind) {
1710 case CASE:
1711 case CASE_DEFAULT:{
1712 break;
1713 }
1714 default:
1715 break label_16;
1716 }
1717 SwitchExpressionCase(cases);
1718 helper.defineCase(cases);
1719 }
1720 jj_consume_token(RCURLY);
1721 jjtree.closeNodeScope(jjtn000, true);
1722 jjtc000 = false;
1723 if (jjtree.nodeCreated()) {
1724 jjtreeCloseNodeScope(jjtn000);
1725 }
1726 jjtn000.jjtSetLastToken(getToken(0));
1727 helper.defineSwitch(jjtn000);
1728 popLoop();
1729 } catch (Throwable jjte000) {
1730 if (jjtc000) {
1731 jjtree.clearNodeScope(jjtn000);
1732 jjtc000 = false;
1733 } else {
1734 jjtree.popNode();
1735 }
1736 if (jjte000 instanceof ParseException) {
1737 throw (ParseException)jjte000;
1738 }
1739 if (jjte000 instanceof RuntimeException) {
1740 throw (RuntimeException)jjte000;
1741 }
1742 throw (Error)jjte000;
1743 } finally {
1744 if (jjtc000) {
1745 jjtree.closeNodeScope(jjtn000, true);
1746 if (jjtree.nodeCreated()) {
1747 jjtreeCloseNodeScope(jjtn000);
1748 }
1749 jjtn000.jjtSetLastToken(getToken(0));
1750 }
1751 }
1752 }
1753
1754 final public void SwitchExpressionCase(SwitchSet cases) throws ParseException {
1755 ASTCaseExpression jjtn000 = new ASTCaseExpression(JJTCASEEXPRESSION);
1756 boolean jjtc000 = true;
1757 jjtree.openNodeScope(jjtn000);
1758 jjtreeOpenNodeScope(jjtn000);
1759 jjtn000.jjtSetFirstToken(getToken(1));List<Object> constants = new ArrayList<Object>(1);
1760 try {
1761 if (jj_2_43(2)) {
1762 jj_consume_token(CASE);
1763 ConstLiterals(constants);
1764 jj_consume_token(LAMBDA);
1765 cases.addAll(constants); jjtn000.setValues(constants);
1766 } else {
1767 switch (jj_nt.kind) {
1768 case CASE_DEFAULT:{
1769 jj_consume_token(CASE_DEFAULT);
1770 jj_consume_token(LAMBDA);
1771 break;
1772 }
1773 default:
1774 jj_consume_token(-1);
1775 throw new ParseException();
1776 }
1777 }
1778 if (jj_2_44(3)) {
1779 Block();
1780 } else if (jj_2_45(1)) {
1781 Expression();
1782 switch (jj_nt.kind) {
1783 case SEMICOL:{
1784 jj_consume_token(SEMICOL);
1785 break;
1786 }
1787 default:
1788 ;
1789 }
1790 } else {
1791 jj_consume_token(-1);
1792 throw new ParseException();
1793 }
1794 } catch (Throwable jjte000) {
1795 if (jjtc000) {
1796 jjtree.clearNodeScope(jjtn000);
1797 jjtc000 = false;
1798 } else {
1799 jjtree.popNode();
1800 }
1801 if (jjte000 instanceof ParseException) {
1802 throw (ParseException)jjte000;
1803 }
1804 if (jjte000 instanceof RuntimeException) {
1805 throw (RuntimeException)jjte000;
1806 }
1807 throw (Error)jjte000;
1808 } finally {
1809 if (jjtc000) {
1810 jjtree.closeNodeScope(jjtn000, true);
1811 if (jjtree.nodeCreated()) {
1812 jjtreeCloseNodeScope(jjtn000);
1813 }
1814 jjtn000.jjtSetLastToken(getToken(0));
1815 }
1816 }
1817 }
1818
1819 final public void ConstLiterals(List<Object> constants) throws ParseException {Object constant;
1820 constant = constLiteral();
1821 constants.add(constant);
1822 label_17:
1823 while (true) {
1824 if (jj_2_46(2)) {
1825 } else {
1826 break label_17;
1827 }
1828 jj_consume_token(COMMA);
1829 constant = constLiteral();
1830 constants.add(constant);
1831 }
1832 }
1833
1834 final public Object constLiteral() throws ParseException {Token s = null;
1835 Token v;
1836 Object result;
1837 LinkedList<String> lstr = new LinkedList<String>();
1838 if (jj_2_47(2)) {
1839 switch (jj_nt.kind) {
1840 case plus:
1841 case minus:{
1842 switch (jj_nt.kind) {
1843 case plus:{
1844 s = jj_consume_token(plus);
1845 break;
1846 }
1847 case minus:{
1848 s = jj_consume_token(minus);
1849 break;
1850 }
1851 default:
1852 jj_consume_token(-1);
1853 throw new ParseException();
1854 }
1855 break;
1856 }
1857 default:
1858 ;
1859 }
1860 v = jj_consume_token(INTEGER_LITERAL);
1861 result = NumberParser.parseInteger(s, v);
1862 } else if (jj_2_48(2)) {
1863 switch (jj_nt.kind) {
1864 case plus:
1865 case minus:{
1866 switch (jj_nt.kind) {
1867 case plus:{
1868 s = jj_consume_token(plus);
1869 break;
1870 }
1871 case minus:{
1872 s = jj_consume_token(minus);
1873 break;
1874 }
1875 default:
1876 jj_consume_token(-1);
1877 throw new ParseException();
1878 }
1879 break;
1880 }
1881 default:
1882 ;
1883 }
1884 v = jj_consume_token(FLOAT_LITERAL);
1885 result = NumberParser.parseDouble(s, v);
1886 } else {
1887 switch (jj_nt.kind) {
1888 case STRING_LITERAL:{
1889 v = jj_consume_token(STRING_LITERAL);
1890 result = Parser.buildString(v.image, true);
1891 break;
1892 }
1893 case TRUE:{
1894 jj_consume_token(TRUE);
1895 result = true;
1896 break;
1897 }
1898 case FALSE:{
1899 jj_consume_token(FALSE);
1900 result = false;
1901 break;
1902 }
1903 case NULL:{
1904 jj_consume_token(NULL);
1905 result = null;
1906 break;
1907 }
1908 case NAN_LITERAL:{
1909 jj_consume_token(NAN_LITERAL);
1910 result = Double.NaN;
1911 break;
1912 }
1913 case DOT:
1914 case IDENTIFIER:{
1915 propertyKey(lstr);
1916 result = resolveConstant(stringify(lstr));
1917 break;
1918 }
1919 default:
1920 jj_consume_token(-1);
1921 throw new ParseException();
1922 }
1923 }
1924 {if ("" != null) return result;}
1925 throw new IllegalStateException ("Missing return statement in function");
1926 }
1927
1928 final public void Import() throws ParseException {List<String> imports = new ArrayList<String>();
1929 jj_consume_token(IMPORT);
1930 propertyKey(imports);
1931 switch (jj_nt.kind) {
1932 case SEMICOL:{
1933 jj_consume_token(SEMICOL);
1934 break;
1935 }
1936 default:
1937 ;
1938 }
1939 addImport(stringify(imports));
1940 }
1941
1942 final public void Pragma() throws ParseException {LinkedList<String> lstr = new LinkedList<String>();
1943 Object value;
1944 jj_consume_token(PRAGMA);
1945 propertyKey(lstr);
1946 value = pragmaValue();
1947 declarePragma(stringify(lstr), value);
1948 }
1949
1950 final public void propertyKey(List<String> lstr) throws ParseException {Token t;
1951 switch (jj_nt.kind) {
1952 case IDENTIFIER:{
1953 t = jj_consume_token(IDENTIFIER);
1954 lstr.add(t.image);
1955 label_18:
1956 while (true) {
1957 if (jj_2_49(2147483647)) {
1958 } else {
1959 break label_18;
1960 }
1961 propertyKey(lstr);
1962 }
1963 break;
1964 }
1965 case DOT:{
1966 jj_consume_token(DOT);
1967 t = jj_consume_token(DOT_IDENTIFIER);
1968 lstr.add(t.image);
1969 break;
1970 }
1971 default:
1972 jj_consume_token(-1);
1973 throw new ParseException();
1974 }
1975 }
1976
1977 final public Object pragmaValue() throws ParseException {Token s = null;
1978 Token v;
1979 LinkedList<String> lstr = new LinkedList<String>();
1980 Object result;
1981 if (jj_2_50(2)) {
1982 switch (jj_nt.kind) {
1983 case plus:
1984 case minus:{
1985 switch (jj_nt.kind) {
1986 case plus:{
1987 s = jj_consume_token(plus);
1988 break;
1989 }
1990 case minus:{
1991 s = jj_consume_token(minus);
1992 break;
1993 }
1994 default:
1995 jj_consume_token(-1);
1996 throw new ParseException();
1997 }
1998 break;
1999 }
2000 default:
2001 ;
2002 }
2003 v = jj_consume_token(INTEGER_LITERAL);
2004 result = NumberParser.parseInteger(s, v);
2005 } else if (jj_2_51(2)) {
2006 switch (jj_nt.kind) {
2007 case plus:
2008 case minus:{
2009 switch (jj_nt.kind) {
2010 case plus:{
2011 s = jj_consume_token(plus);
2012 break;
2013 }
2014 case minus:{
2015 s = jj_consume_token(minus);
2016 break;
2017 }
2018 default:
2019 jj_consume_token(-1);
2020 throw new ParseException();
2021 }
2022 break;
2023 }
2024 default:
2025 ;
2026 }
2027 v = jj_consume_token(FLOAT_LITERAL);
2028 result = NumberParser.parseDouble(s, v);
2029 } else {
2030 switch (jj_nt.kind) {
2031 case STRING_LITERAL:{
2032 v = jj_consume_token(STRING_LITERAL);
2033 result = Parser.buildString(v.image, true);
2034 break;
2035 }
2036 case DOT:
2037 case IDENTIFIER:{
2038 propertyKey(lstr);
2039 result = stringify(lstr);
2040 break;
2041 }
2042 case TRUE:{
2043 jj_consume_token(TRUE);
2044 result = true;
2045 break;
2046 }
2047 case FALSE:{
2048 jj_consume_token(FALSE);
2049 result = false;
2050 break;
2051 }
2052 case NULL:{
2053 jj_consume_token(NULL);
2054 result = null;
2055 break;
2056 }
2057 case NAN_LITERAL:{
2058 jj_consume_token(NAN_LITERAL);
2059 result = Double.NaN;
2060 break;
2061 }
2062 default:
2063 jj_consume_token(-1);
2064 throw new ParseException();
2065 }
2066 }
2067 {if ("" != null) return result;}
2068 throw new IllegalStateException ("Missing return statement in function");
2069 }
2070
2071
2072
2073
2074 final public
2075 void Expression() throws ParseException {
2076 AssignmentExpression();
2077 }
2078
2079 final public void AssignmentExpression() throws ParseException {
2080 ConditionalExpression();
2081 if (jj_2_52(2)) {
2082 switch (jj_nt.kind) {
2083 case plus_assign:{
2084 jj_consume_token(plus_assign);
2085 ASTSetAddNode jjtn001 = new ASTSetAddNode(JJTSETADDNODE);
2086 boolean jjtc001 = true;
2087 jjtree.openNodeScope(jjtn001);
2088 jjtreeOpenNodeScope(jjtn001);
2089 jjtn001.jjtSetFirstToken(getToken(1));
2090 try {
2091 Expression();
2092 } catch (Throwable jjte001) {
2093 if (jjtc001) {
2094 jjtree.clearNodeScope(jjtn001);
2095 jjtc001 = false;
2096 } else {
2097 jjtree.popNode();
2098 }
2099 if (jjte001 instanceof ParseException) {
2100 throw (ParseException)jjte001;
2101 }
2102 if (jjte001 instanceof RuntimeException) {
2103 throw (RuntimeException)jjte001;
2104 }
2105 throw (Error)jjte001;
2106 } finally {
2107 if (jjtc001) {
2108 jjtree.closeNodeScope(jjtn001, 2);
2109 if (jjtree.nodeCreated()) {
2110 jjtreeCloseNodeScope(jjtn001);
2111 }
2112 jjtn001.jjtSetLastToken(getToken(0));
2113 }
2114 }
2115 break;
2116 }
2117 case mult_assign:{
2118 jj_consume_token(mult_assign);
2119 ASTSetMultNode jjtn002 = new ASTSetMultNode(JJTSETMULTNODE);
2120 boolean jjtc002 = true;
2121 jjtree.openNodeScope(jjtn002);
2122 jjtreeOpenNodeScope(jjtn002);
2123 jjtn002.jjtSetFirstToken(getToken(1));
2124 try {
2125 Expression();
2126 } catch (Throwable jjte002) {
2127 if (jjtc002) {
2128 jjtree.clearNodeScope(jjtn002);
2129 jjtc002 = false;
2130 } else {
2131 jjtree.popNode();
2132 }
2133 if (jjte002 instanceof ParseException) {
2134 throw (ParseException)jjte002;
2135 }
2136 if (jjte002 instanceof RuntimeException) {
2137 throw (RuntimeException)jjte002;
2138 }
2139 throw (Error)jjte002;
2140 } finally {
2141 if (jjtc002) {
2142 jjtree.closeNodeScope(jjtn002, 2);
2143 if (jjtree.nodeCreated()) {
2144 jjtreeCloseNodeScope(jjtn002);
2145 }
2146 jjtn002.jjtSetLastToken(getToken(0));
2147 }
2148 }
2149 break;
2150 }
2151 case div_assign:{
2152 jj_consume_token(div_assign);
2153 ASTSetDivNode jjtn003 = new ASTSetDivNode(JJTSETDIVNODE);
2154 boolean jjtc003 = true;
2155 jjtree.openNodeScope(jjtn003);
2156 jjtreeOpenNodeScope(jjtn003);
2157 jjtn003.jjtSetFirstToken(getToken(1));
2158 try {
2159 Expression();
2160 } catch (Throwable jjte003) {
2161 if (jjtc003) {
2162 jjtree.clearNodeScope(jjtn003);
2163 jjtc003 = false;
2164 } else {
2165 jjtree.popNode();
2166 }
2167 if (jjte003 instanceof ParseException) {
2168 throw (ParseException)jjte003;
2169 }
2170 if (jjte003 instanceof RuntimeException) {
2171 throw (RuntimeException)jjte003;
2172 }
2173 throw (Error)jjte003;
2174 } finally {
2175 if (jjtc003) {
2176 jjtree.closeNodeScope(jjtn003, 2);
2177 if (jjtree.nodeCreated()) {
2178 jjtreeCloseNodeScope(jjtn003);
2179 }
2180 jjtn003.jjtSetLastToken(getToken(0));
2181 }
2182 }
2183 break;
2184 }
2185 case mod_assign:{
2186 jj_consume_token(mod_assign);
2187 ASTSetModNode jjtn004 = new ASTSetModNode(JJTSETMODNODE);
2188 boolean jjtc004 = true;
2189 jjtree.openNodeScope(jjtn004);
2190 jjtreeOpenNodeScope(jjtn004);
2191 jjtn004.jjtSetFirstToken(getToken(1));
2192 try {
2193 Expression();
2194 } catch (Throwable jjte004) {
2195 if (jjtc004) {
2196 jjtree.clearNodeScope(jjtn004);
2197 jjtc004 = false;
2198 } else {
2199 jjtree.popNode();
2200 }
2201 if (jjte004 instanceof ParseException) {
2202 throw (ParseException)jjte004;
2203 }
2204 if (jjte004 instanceof RuntimeException) {
2205 throw (RuntimeException)jjte004;
2206 }
2207 throw (Error)jjte004;
2208 } finally {
2209 if (jjtc004) {
2210 jjtree.closeNodeScope(jjtn004, 2);
2211 if (jjtree.nodeCreated()) {
2212 jjtreeCloseNodeScope(jjtn004);
2213 }
2214 jjtn004.jjtSetLastToken(getToken(0));
2215 }
2216 }
2217 break;
2218 }
2219 case and_assign:{
2220 jj_consume_token(and_assign);
2221 ASTSetAndNode jjtn005 = new ASTSetAndNode(JJTSETANDNODE);
2222 boolean jjtc005 = true;
2223 jjtree.openNodeScope(jjtn005);
2224 jjtreeOpenNodeScope(jjtn005);
2225 jjtn005.jjtSetFirstToken(getToken(1));
2226 try {
2227 Expression();
2228 } catch (Throwable jjte005) {
2229 if (jjtc005) {
2230 jjtree.clearNodeScope(jjtn005);
2231 jjtc005 = false;
2232 } else {
2233 jjtree.popNode();
2234 }
2235 if (jjte005 instanceof ParseException) {
2236 throw (ParseException)jjte005;
2237 }
2238 if (jjte005 instanceof RuntimeException) {
2239 throw (RuntimeException)jjte005;
2240 }
2241 throw (Error)jjte005;
2242 } finally {
2243 if (jjtc005) {
2244 jjtree.closeNodeScope(jjtn005, 2);
2245 if (jjtree.nodeCreated()) {
2246 jjtreeCloseNodeScope(jjtn005);
2247 }
2248 jjtn005.jjtSetLastToken(getToken(0));
2249 }
2250 }
2251 break;
2252 }
2253 case or_assign:{
2254 jj_consume_token(or_assign);
2255 ASTSetOrNode jjtn006 = new ASTSetOrNode(JJTSETORNODE);
2256 boolean jjtc006 = true;
2257 jjtree.openNodeScope(jjtn006);
2258 jjtreeOpenNodeScope(jjtn006);
2259 jjtn006.jjtSetFirstToken(getToken(1));
2260 try {
2261 Expression();
2262 } catch (Throwable jjte006) {
2263 if (jjtc006) {
2264 jjtree.clearNodeScope(jjtn006);
2265 jjtc006 = false;
2266 } else {
2267 jjtree.popNode();
2268 }
2269 if (jjte006 instanceof ParseException) {
2270 throw (ParseException)jjte006;
2271 }
2272 if (jjte006 instanceof RuntimeException) {
2273 throw (RuntimeException)jjte006;
2274 }
2275 throw (Error)jjte006;
2276 } finally {
2277 if (jjtc006) {
2278 jjtree.closeNodeScope(jjtn006, 2);
2279 if (jjtree.nodeCreated()) {
2280 jjtreeCloseNodeScope(jjtn006);
2281 }
2282 jjtn006.jjtSetLastToken(getToken(0));
2283 }
2284 }
2285 break;
2286 }
2287 case xor_assign:{
2288 jj_consume_token(xor_assign);
2289 ASTSetXorNode jjtn007 = new ASTSetXorNode(JJTSETXORNODE);
2290 boolean jjtc007 = true;
2291 jjtree.openNodeScope(jjtn007);
2292 jjtreeOpenNodeScope(jjtn007);
2293 jjtn007.jjtSetFirstToken(getToken(1));
2294 try {
2295 Expression();
2296 } catch (Throwable jjte007) {
2297 if (jjtc007) {
2298 jjtree.clearNodeScope(jjtn007);
2299 jjtc007 = false;
2300 } else {
2301 jjtree.popNode();
2302 }
2303 if (jjte007 instanceof ParseException) {
2304 throw (ParseException)jjte007;
2305 }
2306 if (jjte007 instanceof RuntimeException) {
2307 throw (RuntimeException)jjte007;
2308 }
2309 throw (Error)jjte007;
2310 } finally {
2311 if (jjtc007) {
2312 jjtree.closeNodeScope(jjtn007, 2);
2313 if (jjtree.nodeCreated()) {
2314 jjtreeCloseNodeScope(jjtn007);
2315 }
2316 jjtn007.jjtSetLastToken(getToken(0));
2317 }
2318 }
2319 break;
2320 }
2321 case minus_assign:{
2322 jj_consume_token(minus_assign);
2323 ASTSetSubNode jjtn008 = new ASTSetSubNode(JJTSETSUBNODE);
2324 boolean jjtc008 = true;
2325 jjtree.openNodeScope(jjtn008);
2326 jjtreeOpenNodeScope(jjtn008);
2327 jjtn008.jjtSetFirstToken(getToken(1));
2328 try {
2329 Expression();
2330 } catch (Throwable jjte008) {
2331 if (jjtc008) {
2332 jjtree.clearNodeScope(jjtn008);
2333 jjtc008 = false;
2334 } else {
2335 jjtree.popNode();
2336 }
2337 if (jjte008 instanceof ParseException) {
2338 throw (ParseException)jjte008;
2339 }
2340 if (jjte008 instanceof RuntimeException) {
2341 throw (RuntimeException)jjte008;
2342 }
2343 throw (Error)jjte008;
2344 } finally {
2345 if (jjtc008) {
2346 jjtree.closeNodeScope(jjtn008, 2);
2347 if (jjtree.nodeCreated()) {
2348 jjtreeCloseNodeScope(jjtn008);
2349 }
2350 jjtn008.jjtSetLastToken(getToken(0));
2351 }
2352 }
2353 break;
2354 }
2355 case lshift_assign:{
2356 jj_consume_token(lshift_assign);
2357 ASTSetShiftLeftNode jjtn009 = new ASTSetShiftLeftNode(JJTSETSHIFTLEFTNODE);
2358 boolean jjtc009 = true;
2359 jjtree.openNodeScope(jjtn009);
2360 jjtreeOpenNodeScope(jjtn009);
2361 jjtn009.jjtSetFirstToken(getToken(1));
2362 try {
2363 Expression();
2364 } catch (Throwable jjte009) {
2365 if (jjtc009) {
2366 jjtree.clearNodeScope(jjtn009);
2367 jjtc009 = false;
2368 } else {
2369 jjtree.popNode();
2370 }
2371 if (jjte009 instanceof ParseException) {
2372 throw (ParseException)jjte009;
2373 }
2374 if (jjte009 instanceof RuntimeException) {
2375 throw (RuntimeException)jjte009;
2376 }
2377 throw (Error)jjte009;
2378 } finally {
2379 if (jjtc009) {
2380 jjtree.closeNodeScope(jjtn009, 2);
2381 if (jjtree.nodeCreated()) {
2382 jjtreeCloseNodeScope(jjtn009);
2383 }
2384 jjtn009.jjtSetLastToken(getToken(0));
2385 }
2386 }
2387 break;
2388 }
2389 case rshift_assign:{
2390 jj_consume_token(rshift_assign);
2391 ASTSetShiftRightNode jjtn010 = new ASTSetShiftRightNode(JJTSETSHIFTRIGHTNODE);
2392 boolean jjtc010 = true;
2393 jjtree.openNodeScope(jjtn010);
2394 jjtreeOpenNodeScope(jjtn010);
2395 jjtn010.jjtSetFirstToken(getToken(1));
2396 try {
2397 Expression();
2398 } catch (Throwable jjte010) {
2399 if (jjtc010) {
2400 jjtree.clearNodeScope(jjtn010);
2401 jjtc010 = false;
2402 } else {
2403 jjtree.popNode();
2404 }
2405 if (jjte010 instanceof ParseException) {
2406 throw (ParseException)jjte010;
2407 }
2408 if (jjte010 instanceof RuntimeException) {
2409 throw (RuntimeException)jjte010;
2410 }
2411 throw (Error)jjte010;
2412 } finally {
2413 if (jjtc010) {
2414 jjtree.closeNodeScope(jjtn010, 2);
2415 if (jjtree.nodeCreated()) {
2416 jjtreeCloseNodeScope(jjtn010);
2417 }
2418 jjtn010.jjtSetLastToken(getToken(0));
2419 }
2420 }
2421 break;
2422 }
2423 case rshiftu_assign:{
2424 jj_consume_token(rshiftu_assign);
2425 ASTSetShiftRightUnsignedNode jjtn011 = new ASTSetShiftRightUnsignedNode(JJTSETSHIFTRIGHTUNSIGNEDNODE);
2426 boolean jjtc011 = true;
2427 jjtree.openNodeScope(jjtn011);
2428 jjtreeOpenNodeScope(jjtn011);
2429 jjtn011.jjtSetFirstToken(getToken(1));
2430 try {
2431 Expression();
2432 } catch (Throwable jjte011) {
2433 if (jjtc011) {
2434 jjtree.clearNodeScope(jjtn011);
2435 jjtc011 = false;
2436 } else {
2437 jjtree.popNode();
2438 }
2439 if (jjte011 instanceof ParseException) {
2440 throw (ParseException)jjte011;
2441 }
2442 if (jjte011 instanceof RuntimeException) {
2443 throw (RuntimeException)jjte011;
2444 }
2445 throw (Error)jjte011;
2446 } finally {
2447 if (jjtc011) {
2448 jjtree.closeNodeScope(jjtn011, 2);
2449 if (jjtree.nodeCreated()) {
2450 jjtreeCloseNodeScope(jjtn011);
2451 }
2452 jjtn011.jjtSetLastToken(getToken(0));
2453 }
2454 }
2455 break;
2456 }
2457 case assign:{
2458 jj_consume_token(assign);
2459 ASTAssignment jjtn012 = new ASTAssignment(JJTASSIGNMENT);
2460 boolean jjtc012 = true;
2461 jjtree.openNodeScope(jjtn012);
2462 jjtreeOpenNodeScope(jjtn012);
2463 jjtn012.jjtSetFirstToken(getToken(1));
2464 try {
2465 Expression();
2466 } catch (Throwable jjte012) {
2467 if (jjtc012) {
2468 jjtree.clearNodeScope(jjtn012);
2469 jjtc012 = false;
2470 } else {
2471 jjtree.popNode();
2472 }
2473 if (jjte012 instanceof ParseException) {
2474 throw (ParseException)jjte012;
2475 }
2476 if (jjte012 instanceof RuntimeException) {
2477 throw (RuntimeException)jjte012;
2478 }
2479 throw (Error)jjte012;
2480 } finally {
2481 if (jjtc012) {
2482 jjtree.closeNodeScope(jjtn012, 2);
2483 if (jjtree.nodeCreated()) {
2484 jjtreeCloseNodeScope(jjtn012);
2485 }
2486 jjtn012.jjtSetLastToken(getToken(0));
2487 }
2488 }
2489 break;
2490 }
2491 default:
2492 jj_consume_token(-1);
2493 throw new ParseException();
2494 }
2495 } else {
2496 ;
2497 }
2498 }
2499
2500
2501
2502
2503 final public
2504 void ConditionalExpression() throws ParseException {
2505 ConditionalOrExpression();
2506 if (jj_2_53(2)) {
2507 switch (jj_nt.kind) {
2508 case QMARK:{
2509 jj_consume_token(QMARK);
2510 Expression();
2511 jj_consume_token(COLON);
2512 ASTTernaryNode jjtn001 = new ASTTernaryNode(JJTTERNARYNODE);
2513 boolean jjtc001 = true;
2514 jjtree.openNodeScope(jjtn001);
2515 jjtreeOpenNodeScope(jjtn001);
2516 jjtn001.jjtSetFirstToken(getToken(1));
2517 try {
2518 Expression();
2519 } catch (Throwable jjte001) {
2520 if (jjtc001) {
2521 jjtree.clearNodeScope(jjtn001);
2522 jjtc001 = false;
2523 } else {
2524 jjtree.popNode();
2525 }
2526 if (jjte001 instanceof ParseException) {
2527 throw (ParseException)jjte001;
2528 }
2529 if (jjte001 instanceof RuntimeException) {
2530 throw (RuntimeException)jjte001;
2531 }
2532 throw (Error)jjte001;
2533 } finally {
2534 if (jjtc001) {
2535 jjtree.closeNodeScope(jjtn001, 3);
2536 if (jjtree.nodeCreated()) {
2537 jjtreeCloseNodeScope(jjtn001);
2538 }
2539 jjtn001.jjtSetLastToken(getToken(0));
2540 }
2541 }
2542 break;
2543 }
2544 case ELVIS:{
2545 jj_consume_token(ELVIS);
2546 ASTTernaryNode jjtn002 = new ASTTernaryNode(JJTTERNARYNODE);
2547 boolean jjtc002 = true;
2548 jjtree.openNodeScope(jjtn002);
2549 jjtreeOpenNodeScope(jjtn002);
2550 jjtn002.jjtSetFirstToken(getToken(1));
2551 try {
2552 Expression();
2553 } catch (Throwable jjte002) {
2554 if (jjtc002) {
2555 jjtree.clearNodeScope(jjtn002);
2556 jjtc002 = false;
2557 } else {
2558 jjtree.popNode();
2559 }
2560 if (jjte002 instanceof ParseException) {
2561 throw (ParseException)jjte002;
2562 }
2563 if (jjte002 instanceof RuntimeException) {
2564 throw (RuntimeException)jjte002;
2565 }
2566 throw (Error)jjte002;
2567 } finally {
2568 if (jjtc002) {
2569 jjtree.closeNodeScope(jjtn002, 2);
2570 if (jjtree.nodeCreated()) {
2571 jjtreeCloseNodeScope(jjtn002);
2572 }
2573 jjtn002.jjtSetLastToken(getToken(0));
2574 }
2575 }
2576 break;
2577 }
2578 case NULLP:{
2579 jj_consume_token(NULLP);
2580 ASTNullpNode jjtn003 = new ASTNullpNode(JJTNULLPNODE);
2581 boolean jjtc003 = true;
2582 jjtree.openNodeScope(jjtn003);
2583 jjtreeOpenNodeScope(jjtn003);
2584 jjtn003.jjtSetFirstToken(getToken(1));
2585 try {
2586 Expression();
2587 } catch (Throwable jjte003) {
2588 if (jjtc003) {
2589 jjtree.clearNodeScope(jjtn003);
2590 jjtc003 = false;
2591 } else {
2592 jjtree.popNode();
2593 }
2594 if (jjte003 instanceof ParseException) {
2595 throw (ParseException)jjte003;
2596 }
2597 if (jjte003 instanceof RuntimeException) {
2598 throw (RuntimeException)jjte003;
2599 }
2600 throw (Error)jjte003;
2601 } finally {
2602 if (jjtc003) {
2603 jjtree.closeNodeScope(jjtn003, 2);
2604 if (jjtree.nodeCreated()) {
2605 jjtreeCloseNodeScope(jjtn003);
2606 }
2607 jjtn003.jjtSetLastToken(getToken(0));
2608 }
2609 }
2610 break;
2611 }
2612 default:
2613 jj_consume_token(-1);
2614 throw new ParseException();
2615 }
2616 } else {
2617 ;
2618 }
2619 }
2620
2621 final public void ConditionalOrExpression() throws ParseException {
2622 ASTOrNode jjtn001 = new ASTOrNode(JJTORNODE);
2623 boolean jjtc001 = true;
2624 jjtree.openNodeScope(jjtn001);
2625 jjtreeOpenNodeScope(jjtn001);
2626 jjtn001.jjtSetFirstToken(getToken(1));
2627 try {
2628 ConditionalAndExpression();
2629 label_19:
2630 while (true) {
2631 if (jj_2_54(2)) {
2632 } else {
2633 break label_19;
2634 }
2635 switch (jj_nt.kind) {
2636 case OR:{
2637 jj_consume_token(OR);
2638 break;
2639 }
2640 case _OR:{
2641 jj_consume_token(_OR);
2642 break;
2643 }
2644 default:
2645 jj_consume_token(-1);
2646 throw new ParseException();
2647 }
2648 ConditionalAndExpression();
2649 }
2650 } catch (Throwable jjte001) {
2651 if (jjtc001) {
2652 jjtree.clearNodeScope(jjtn001);
2653 jjtc001 = false;
2654 } else {
2655 jjtree.popNode();
2656 }
2657 if (jjte001 instanceof ParseException) {
2658 throw (ParseException)jjte001;
2659 }
2660 if (jjte001 instanceof RuntimeException) {
2661 throw (RuntimeException)jjte001;
2662 }
2663 throw (Error)jjte001;
2664 } finally {
2665 if (jjtc001) {
2666 jjtree.closeNodeScope(jjtn001, jjtree.nodeArity() > 1);
2667 if (jjtree.nodeCreated()) {
2668 jjtreeCloseNodeScope(jjtn001);
2669 }
2670 jjtn001.jjtSetLastToken(getToken(0));
2671 }
2672 }
2673 }
2674
2675 final public void ConditionalAndExpression() throws ParseException {
2676 ASTAndNode jjtn001 = new ASTAndNode(JJTANDNODE);
2677 boolean jjtc001 = true;
2678 jjtree.openNodeScope(jjtn001);
2679 jjtreeOpenNodeScope(jjtn001);
2680 jjtn001.jjtSetFirstToken(getToken(1));
2681 try {
2682 InclusiveOrExpression();
2683 label_20:
2684 while (true) {
2685 if (jj_2_55(2)) {
2686 } else {
2687 break label_20;
2688 }
2689 switch (jj_nt.kind) {
2690 case AND:{
2691 jj_consume_token(AND);
2692 break;
2693 }
2694 case _AND:{
2695 jj_consume_token(_AND);
2696 break;
2697 }
2698 default:
2699 jj_consume_token(-1);
2700 throw new ParseException();
2701 }
2702 InclusiveOrExpression();
2703 }
2704 } catch (Throwable jjte001) {
2705 if (jjtc001) {
2706 jjtree.clearNodeScope(jjtn001);
2707 jjtc001 = false;
2708 } else {
2709 jjtree.popNode();
2710 }
2711 if (jjte001 instanceof ParseException) {
2712 throw (ParseException)jjte001;
2713 }
2714 if (jjte001 instanceof RuntimeException) {
2715 throw (RuntimeException)jjte001;
2716 }
2717 throw (Error)jjte001;
2718 } finally {
2719 if (jjtc001) {
2720 jjtree.closeNodeScope(jjtn001, jjtree.nodeArity() > 1);
2721 if (jjtree.nodeCreated()) {
2722 jjtreeCloseNodeScope(jjtn001);
2723 }
2724 jjtn001.jjtSetLastToken(getToken(0));
2725 }
2726 }
2727 }
2728
2729 final public void InclusiveOrExpression() throws ParseException {
2730 ExclusiveOrExpression();
2731 label_21:
2732 while (true) {
2733 if (jj_2_56(2)) {
2734 } else {
2735 break label_21;
2736 }
2737 jj_consume_token(or);
2738 ASTBitwiseOrNode jjtn001 = new ASTBitwiseOrNode(JJTBITWISEORNODE);
2739 boolean jjtc001 = true;
2740 jjtree.openNodeScope(jjtn001);
2741 jjtreeOpenNodeScope(jjtn001);
2742 jjtn001.jjtSetFirstToken(getToken(1));
2743 try {
2744 ExclusiveOrExpression();
2745 } catch (Throwable jjte001) {
2746 if (jjtc001) {
2747 jjtree.clearNodeScope(jjtn001);
2748 jjtc001 = false;
2749 } else {
2750 jjtree.popNode();
2751 }
2752 if (jjte001 instanceof ParseException) {
2753 throw (ParseException)jjte001;
2754 }
2755 if (jjte001 instanceof RuntimeException) {
2756 throw (RuntimeException)jjte001;
2757 }
2758 throw (Error)jjte001;
2759 } finally {
2760 if (jjtc001) {
2761 jjtree.closeNodeScope(jjtn001, 2);
2762 if (jjtree.nodeCreated()) {
2763 jjtreeCloseNodeScope(jjtn001);
2764 }
2765 jjtn001.jjtSetLastToken(getToken(0));
2766 }
2767 }
2768 }
2769 }
2770
2771 final public void ExclusiveOrExpression() throws ParseException {
2772 AndExpression();
2773 label_22:
2774 while (true) {
2775 if (jj_2_57(2)) {
2776 } else {
2777 break label_22;
2778 }
2779 jj_consume_token(xor);
2780 ASTBitwiseXorNode jjtn001 = new ASTBitwiseXorNode(JJTBITWISEXORNODE);
2781 boolean jjtc001 = true;
2782 jjtree.openNodeScope(jjtn001);
2783 jjtreeOpenNodeScope(jjtn001);
2784 jjtn001.jjtSetFirstToken(getToken(1));
2785 try {
2786 AndExpression();
2787 } catch (Throwable jjte001) {
2788 if (jjtc001) {
2789 jjtree.clearNodeScope(jjtn001);
2790 jjtc001 = false;
2791 } else {
2792 jjtree.popNode();
2793 }
2794 if (jjte001 instanceof ParseException) {
2795 throw (ParseException)jjte001;
2796 }
2797 if (jjte001 instanceof RuntimeException) {
2798 throw (RuntimeException)jjte001;
2799 }
2800 throw (Error)jjte001;
2801 } finally {
2802 if (jjtc001) {
2803 jjtree.closeNodeScope(jjtn001, 2);
2804 if (jjtree.nodeCreated()) {
2805 jjtreeCloseNodeScope(jjtn001);
2806 }
2807 jjtn001.jjtSetLastToken(getToken(0));
2808 }
2809 }
2810 }
2811 }
2812
2813 final public void AndExpression() throws ParseException {
2814 EqualityExpression();
2815 label_23:
2816 while (true) {
2817 if (jj_2_58(2)) {
2818 } else {
2819 break label_23;
2820 }
2821 jj_consume_token(and);
2822 ASTBitwiseAndNode jjtn001 = new ASTBitwiseAndNode(JJTBITWISEANDNODE);
2823 boolean jjtc001 = true;
2824 jjtree.openNodeScope(jjtn001);
2825 jjtreeOpenNodeScope(jjtn001);
2826 jjtn001.jjtSetFirstToken(getToken(1));
2827 try {
2828 EqualityExpression();
2829 } catch (Throwable jjte001) {
2830 if (jjtc001) {
2831 jjtree.clearNodeScope(jjtn001);
2832 jjtc001 = false;
2833 } else {
2834 jjtree.popNode();
2835 }
2836 if (jjte001 instanceof ParseException) {
2837 throw (ParseException)jjte001;
2838 }
2839 if (jjte001 instanceof RuntimeException) {
2840 throw (RuntimeException)jjte001;
2841 }
2842 throw (Error)jjte001;
2843 } finally {
2844 if (jjtc001) {
2845 jjtree.closeNodeScope(jjtn001, 2);
2846 if (jjtree.nodeCreated()) {
2847 jjtreeCloseNodeScope(jjtn001);
2848 }
2849 jjtn001.jjtSetLastToken(getToken(0));
2850 }
2851 }
2852 }
2853 }
2854
2855 final public void EqualityExpression() throws ParseException {
2856 RelationalExpression();
2857 if (jj_2_59(2)) {
2858 switch (jj_nt.kind) {
2859 case eq:
2860 case EQ:{
2861 switch (jj_nt.kind) {
2862 case eq:{
2863 jj_consume_token(eq);
2864 break;
2865 }
2866 case EQ:{
2867 jj_consume_token(EQ);
2868 break;
2869 }
2870 default:
2871 jj_consume_token(-1);
2872 throw new ParseException();
2873 }
2874 ASTEQNode jjtn001 = new ASTEQNode(JJTEQNODE);
2875 boolean jjtc001 = true;
2876 jjtree.openNodeScope(jjtn001);
2877 jjtreeOpenNodeScope(jjtn001);
2878 jjtn001.jjtSetFirstToken(getToken(1));
2879 try {
2880 RelationalExpression();
2881 } catch (Throwable jjte001) {
2882 if (jjtc001) {
2883 jjtree.clearNodeScope(jjtn001);
2884 jjtc001 = false;
2885 } else {
2886 jjtree.popNode();
2887 }
2888 if (jjte001 instanceof ParseException) {
2889 throw (ParseException)jjte001;
2890 }
2891 if (jjte001 instanceof RuntimeException) {
2892 throw (RuntimeException)jjte001;
2893 }
2894 throw (Error)jjte001;
2895 } finally {
2896 if (jjtc001) {
2897 jjtree.closeNodeScope(jjtn001, 2);
2898 if (jjtree.nodeCreated()) {
2899 jjtreeCloseNodeScope(jjtn001);
2900 }
2901 jjtn001.jjtSetLastToken(getToken(0));
2902 }
2903 }
2904 break;
2905 }
2906 case ne:
2907 case NE:{
2908 switch (jj_nt.kind) {
2909 case ne:{
2910 jj_consume_token(ne);
2911 break;
2912 }
2913 case NE:{
2914 jj_consume_token(NE);
2915 break;
2916 }
2917 default:
2918 jj_consume_token(-1);
2919 throw new ParseException();
2920 }
2921 ASTNENode jjtn002 = new ASTNENode(JJTNENODE);
2922 boolean jjtc002 = true;
2923 jjtree.openNodeScope(jjtn002);
2924 jjtreeOpenNodeScope(jjtn002);
2925 jjtn002.jjtSetFirstToken(getToken(1));
2926 try {
2927 RelationalExpression();
2928 } catch (Throwable jjte002) {
2929 if (jjtc002) {
2930 jjtree.clearNodeScope(jjtn002);
2931 jjtc002 = false;
2932 } else {
2933 jjtree.popNode();
2934 }
2935 if (jjte002 instanceof ParseException) {
2936 throw (ParseException)jjte002;
2937 }
2938 if (jjte002 instanceof RuntimeException) {
2939 throw (RuntimeException)jjte002;
2940 }
2941 throw (Error)jjte002;
2942 } finally {
2943 if (jjtc002) {
2944 jjtree.closeNodeScope(jjtn002, 2);
2945 if (jjtree.nodeCreated()) {
2946 jjtreeCloseNodeScope(jjtn002);
2947 }
2948 jjtn002.jjtSetLastToken(getToken(0));
2949 }
2950 }
2951 break;
2952 }
2953 case eqstrict:{
2954 jj_consume_token(eqstrict);
2955 ASTEQSNode jjtn003 = new ASTEQSNode(JJTEQSNODE);
2956 boolean jjtc003 = true;
2957 jjtree.openNodeScope(jjtn003);
2958 jjtreeOpenNodeScope(jjtn003);
2959 jjtn003.jjtSetFirstToken(getToken(1));
2960 try {
2961 RelationalExpression();
2962 } catch (Throwable jjte003) {
2963 if (jjtc003) {
2964 jjtree.clearNodeScope(jjtn003);
2965 jjtc003 = false;
2966 } else {
2967 jjtree.popNode();
2968 }
2969 if (jjte003 instanceof ParseException) {
2970 throw (ParseException)jjte003;
2971 }
2972 if (jjte003 instanceof RuntimeException) {
2973 throw (RuntimeException)jjte003;
2974 }
2975 throw (Error)jjte003;
2976 } finally {
2977 if (jjtc003) {
2978 jjtree.closeNodeScope(jjtn003, 2);
2979 if (jjtree.nodeCreated()) {
2980 jjtreeCloseNodeScope(jjtn003);
2981 }
2982 jjtn003.jjtSetLastToken(getToken(0));
2983 }
2984 }
2985 break;
2986 }
2987 case neqstrict:{
2988 jj_consume_token(neqstrict);
2989 ASTNESNode jjtn004 = new ASTNESNode(JJTNESNODE);
2990 boolean jjtc004 = true;
2991 jjtree.openNodeScope(jjtn004);
2992 jjtreeOpenNodeScope(jjtn004);
2993 jjtn004.jjtSetFirstToken(getToken(1));
2994 try {
2995 RelationalExpression();
2996 } catch (Throwable jjte004) {
2997 if (jjtc004) {
2998 jjtree.clearNodeScope(jjtn004);
2999 jjtc004 = false;
3000 } else {
3001 jjtree.popNode();
3002 }
3003 if (jjte004 instanceof ParseException) {
3004 throw (ParseException)jjte004;
3005 }
3006 if (jjte004 instanceof RuntimeException) {
3007 throw (RuntimeException)jjte004;
3008 }
3009 throw (Error)jjte004;
3010 } finally {
3011 if (jjtc004) {
3012 jjtree.closeNodeScope(jjtn004, 2);
3013 if (jjtree.nodeCreated()) {
3014 jjtreeCloseNodeScope(jjtn004);
3015 }
3016 jjtn004.jjtSetLastToken(getToken(0));
3017 }
3018 }
3019 break;
3020 }
3021 case range:{
3022 jj_consume_token(range);
3023 ASTRangeNode jjtn005 = new ASTRangeNode(JJTRANGENODE);
3024 boolean jjtc005 = true;
3025 jjtree.openNodeScope(jjtn005);
3026 jjtreeOpenNodeScope(jjtn005);
3027 jjtn005.jjtSetFirstToken(getToken(1));
3028 try {
3029 RelationalExpression();
3030 } catch (Throwable jjte005) {
3031 if (jjtc005) {
3032 jjtree.clearNodeScope(jjtn005);
3033 jjtc005 = false;
3034 } else {
3035 jjtree.popNode();
3036 }
3037 if (jjte005 instanceof ParseException) {
3038 throw (ParseException)jjte005;
3039 }
3040 if (jjte005 instanceof RuntimeException) {
3041 throw (RuntimeException)jjte005;
3042 }
3043 throw (Error)jjte005;
3044 } finally {
3045 if (jjtc005) {
3046 jjtree.closeNodeScope(jjtn005, 2);
3047 if (jjtree.nodeCreated()) {
3048 jjtreeCloseNodeScope(jjtn005);
3049 }
3050 jjtn005.jjtSetLastToken(getToken(0));
3051 }
3052 }
3053 break;
3054 }
3055 default:
3056 jj_consume_token(-1);
3057 throw new ParseException();
3058 }
3059 } else {
3060 ;
3061 }
3062 }
3063
3064 final public void RelationalExpression() throws ParseException {
3065 ShiftExpression();
3066 if (jj_2_60(2)) {
3067 switch (jj_nt.kind) {
3068 case lt:
3069 case LT:{
3070 switch (jj_nt.kind) {
3071 case lt:{
3072 jj_consume_token(lt);
3073 break;
3074 }
3075 case LT:{
3076 jj_consume_token(LT);
3077 break;
3078 }
3079 default:
3080 jj_consume_token(-1);
3081 throw new ParseException();
3082 }
3083 ASTLTNode jjtn001 = new ASTLTNode(JJTLTNODE);
3084 boolean jjtc001 = true;
3085 jjtree.openNodeScope(jjtn001);
3086 jjtreeOpenNodeScope(jjtn001);
3087 jjtn001.jjtSetFirstToken(getToken(1));
3088 try {
3089 ShiftExpression();
3090 } catch (Throwable jjte001) {
3091 if (jjtc001) {
3092 jjtree.clearNodeScope(jjtn001);
3093 jjtc001 = false;
3094 } else {
3095 jjtree.popNode();
3096 }
3097 if (jjte001 instanceof ParseException) {
3098 throw (ParseException)jjte001;
3099 }
3100 if (jjte001 instanceof RuntimeException) {
3101 throw (RuntimeException)jjte001;
3102 }
3103 throw (Error)jjte001;
3104 } finally {
3105 if (jjtc001) {
3106 jjtree.closeNodeScope(jjtn001, 2);
3107 if (jjtree.nodeCreated()) {
3108 jjtreeCloseNodeScope(jjtn001);
3109 }
3110 jjtn001.jjtSetLastToken(getToken(0));
3111 }
3112 }
3113 break;
3114 }
3115 case gt:
3116 case GT:{
3117 switch (jj_nt.kind) {
3118 case gt:{
3119 jj_consume_token(gt);
3120 break;
3121 }
3122 case GT:{
3123 jj_consume_token(GT);
3124 break;
3125 }
3126 default:
3127 jj_consume_token(-1);
3128 throw new ParseException();
3129 }
3130 ASTGTNode jjtn002 = new ASTGTNode(JJTGTNODE);
3131 boolean jjtc002 = true;
3132 jjtree.openNodeScope(jjtn002);
3133 jjtreeOpenNodeScope(jjtn002);
3134 jjtn002.jjtSetFirstToken(getToken(1));
3135 try {
3136 ShiftExpression();
3137 } catch (Throwable jjte002) {
3138 if (jjtc002) {
3139 jjtree.clearNodeScope(jjtn002);
3140 jjtc002 = false;
3141 } else {
3142 jjtree.popNode();
3143 }
3144 if (jjte002 instanceof ParseException) {
3145 throw (ParseException)jjte002;
3146 }
3147 if (jjte002 instanceof RuntimeException) {
3148 throw (RuntimeException)jjte002;
3149 }
3150 throw (Error)jjte002;
3151 } finally {
3152 if (jjtc002) {
3153 jjtree.closeNodeScope(jjtn002, 2);
3154 if (jjtree.nodeCreated()) {
3155 jjtreeCloseNodeScope(jjtn002);
3156 }
3157 jjtn002.jjtSetLastToken(getToken(0));
3158 }
3159 }
3160 break;
3161 }
3162 case le:
3163 case LE:{
3164 switch (jj_nt.kind) {
3165 case le:{
3166 jj_consume_token(le);
3167 break;
3168 }
3169 case LE:{
3170 jj_consume_token(LE);
3171 break;
3172 }
3173 default:
3174 jj_consume_token(-1);
3175 throw new ParseException();
3176 }
3177 ASTLENode jjtn003 = new ASTLENode(JJTLENODE);
3178 boolean jjtc003 = true;
3179 jjtree.openNodeScope(jjtn003);
3180 jjtreeOpenNodeScope(jjtn003);
3181 jjtn003.jjtSetFirstToken(getToken(1));
3182 try {
3183 ShiftExpression();
3184 } catch (Throwable jjte003) {
3185 if (jjtc003) {
3186 jjtree.clearNodeScope(jjtn003);
3187 jjtc003 = false;
3188 } else {
3189 jjtree.popNode();
3190 }
3191 if (jjte003 instanceof ParseException) {
3192 throw (ParseException)jjte003;
3193 }
3194 if (jjte003 instanceof RuntimeException) {
3195 throw (RuntimeException)jjte003;
3196 }
3197 throw (Error)jjte003;
3198 } finally {
3199 if (jjtc003) {
3200 jjtree.closeNodeScope(jjtn003, 2);
3201 if (jjtree.nodeCreated()) {
3202 jjtreeCloseNodeScope(jjtn003);
3203 }
3204 jjtn003.jjtSetLastToken(getToken(0));
3205 }
3206 }
3207 break;
3208 }
3209 case ge:
3210 case GE:{
3211 switch (jj_nt.kind) {
3212 case ge:{
3213 jj_consume_token(ge);
3214 break;
3215 }
3216 case GE:{
3217 jj_consume_token(GE);
3218 break;
3219 }
3220 default:
3221 jj_consume_token(-1);
3222 throw new ParseException();
3223 }
3224 ASTGENode jjtn004 = new ASTGENode(JJTGENODE);
3225 boolean jjtc004 = true;
3226 jjtree.openNodeScope(jjtn004);
3227 jjtreeOpenNodeScope(jjtn004);
3228 jjtn004.jjtSetFirstToken(getToken(1));
3229 try {
3230 ShiftExpression();
3231 } catch (Throwable jjte004) {
3232 if (jjtc004) {
3233 jjtree.clearNodeScope(jjtn004);
3234 jjtc004 = false;
3235 } else {
3236 jjtree.popNode();
3237 }
3238 if (jjte004 instanceof ParseException) {
3239 throw (ParseException)jjte004;
3240 }
3241 if (jjte004 instanceof RuntimeException) {
3242 throw (RuntimeException)jjte004;
3243 }
3244 throw (Error)jjte004;
3245 } finally {
3246 if (jjtc004) {
3247 jjtree.closeNodeScope(jjtn004, 2);
3248 if (jjtree.nodeCreated()) {
3249 jjtreeCloseNodeScope(jjtn004);
3250 }
3251 jjtn004.jjtSetLastToken(getToken(0));
3252 }
3253 }
3254 break;
3255 }
3256 case req:{
3257 jj_consume_token(req);
3258 ASTERNode jjtn005 = new ASTERNode(JJTERNODE);
3259 boolean jjtc005 = true;
3260 jjtree.openNodeScope(jjtn005);
3261 jjtreeOpenNodeScope(jjtn005);
3262 jjtn005.jjtSetFirstToken(getToken(1));
3263 try {
3264 ShiftExpression();
3265 } catch (Throwable jjte005) {
3266 if (jjtc005) {
3267 jjtree.clearNodeScope(jjtn005);
3268 jjtc005 = false;
3269 } else {
3270 jjtree.popNode();
3271 }
3272 if (jjte005 instanceof ParseException) {
3273 throw (ParseException)jjte005;
3274 }
3275 if (jjte005 instanceof RuntimeException) {
3276 throw (RuntimeException)jjte005;
3277 }
3278 throw (Error)jjte005;
3279 } finally {
3280 if (jjtc005) {
3281 jjtree.closeNodeScope(jjtn005, 2);
3282 if (jjtree.nodeCreated()) {
3283 jjtreeCloseNodeScope(jjtn005);
3284 }
3285 jjtn005.jjtSetLastToken(getToken(0));
3286 }
3287 }
3288 break;
3289 }
3290 case rne:{
3291 jj_consume_token(rne);
3292 ASTNRNode jjtn006 = new ASTNRNode(JJTNRNODE);
3293 boolean jjtc006 = true;
3294 jjtree.openNodeScope(jjtn006);
3295 jjtreeOpenNodeScope(jjtn006);
3296 jjtn006.jjtSetFirstToken(getToken(1));
3297 try {
3298 ShiftExpression();
3299 } catch (Throwable jjte006) {
3300 if (jjtc006) {
3301 jjtree.clearNodeScope(jjtn006);
3302 jjtc006 = false;
3303 } else {
3304 jjtree.popNode();
3305 }
3306 if (jjte006 instanceof ParseException) {
3307 throw (ParseException)jjte006;
3308 }
3309 if (jjte006 instanceof RuntimeException) {
3310 throw (RuntimeException)jjte006;
3311 }
3312 throw (Error)jjte006;
3313 } finally {
3314 if (jjtc006) {
3315 jjtree.closeNodeScope(jjtn006, 2);
3316 if (jjtree.nodeCreated()) {
3317 jjtreeCloseNodeScope(jjtn006);
3318 }
3319 jjtn006.jjtSetLastToken(getToken(0));
3320 }
3321 }
3322 break;
3323 }
3324 case seq:{
3325 jj_consume_token(seq);
3326 ASTSWNode jjtn007 = new ASTSWNode(JJTSWNODE);
3327 boolean jjtc007 = true;
3328 jjtree.openNodeScope(jjtn007);
3329 jjtreeOpenNodeScope(jjtn007);
3330 jjtn007.jjtSetFirstToken(getToken(1));
3331 try {
3332 ShiftExpression();
3333 } catch (Throwable jjte007) {
3334 if (jjtc007) {
3335 jjtree.clearNodeScope(jjtn007);
3336 jjtc007 = false;
3337 } else {
3338 jjtree.popNode();
3339 }
3340 if (jjte007 instanceof ParseException) {
3341 throw (ParseException)jjte007;
3342 }
3343 if (jjte007 instanceof RuntimeException) {
3344 throw (RuntimeException)jjte007;
3345 }
3346 throw (Error)jjte007;
3347 } finally {
3348 if (jjtc007) {
3349 jjtree.closeNodeScope(jjtn007, 2);
3350 if (jjtree.nodeCreated()) {
3351 jjtreeCloseNodeScope(jjtn007);
3352 }
3353 jjtn007.jjtSetLastToken(getToken(0));
3354 }
3355 }
3356 break;
3357 }
3358 case sne:{
3359 jj_consume_token(sne);
3360 ASTNSWNode jjtn008 = new ASTNSWNode(JJTNSWNODE);
3361 boolean jjtc008 = true;
3362 jjtree.openNodeScope(jjtn008);
3363 jjtreeOpenNodeScope(jjtn008);
3364 jjtn008.jjtSetFirstToken(getToken(1));
3365 try {
3366 ShiftExpression();
3367 } catch (Throwable jjte008) {
3368 if (jjtc008) {
3369 jjtree.clearNodeScope(jjtn008);
3370 jjtc008 = false;
3371 } else {
3372 jjtree.popNode();
3373 }
3374 if (jjte008 instanceof ParseException) {
3375 throw (ParseException)jjte008;
3376 }
3377 if (jjte008 instanceof RuntimeException) {
3378 throw (RuntimeException)jjte008;
3379 }
3380 throw (Error)jjte008;
3381 } finally {
3382 if (jjtc008) {
3383 jjtree.closeNodeScope(jjtn008, 2);
3384 if (jjtree.nodeCreated()) {
3385 jjtreeCloseNodeScope(jjtn008);
3386 }
3387 jjtn008.jjtSetLastToken(getToken(0));
3388 }
3389 }
3390 break;
3391 }
3392 case eeq:{
3393 jj_consume_token(eeq);
3394 ASTEWNode jjtn009 = new ASTEWNode(JJTEWNODE);
3395 boolean jjtc009 = true;
3396 jjtree.openNodeScope(jjtn009);
3397 jjtreeOpenNodeScope(jjtn009);
3398 jjtn009.jjtSetFirstToken(getToken(1));
3399 try {
3400 ShiftExpression();
3401 } catch (Throwable jjte009) {
3402 if (jjtc009) {
3403 jjtree.clearNodeScope(jjtn009);
3404 jjtc009 = false;
3405 } else {
3406 jjtree.popNode();
3407 }
3408 if (jjte009 instanceof ParseException) {
3409 throw (ParseException)jjte009;
3410 }
3411 if (jjte009 instanceof RuntimeException) {
3412 throw (RuntimeException)jjte009;
3413 }
3414 throw (Error)jjte009;
3415 } finally {
3416 if (jjtc009) {
3417 jjtree.closeNodeScope(jjtn009, 2);
3418 if (jjtree.nodeCreated()) {
3419 jjtreeCloseNodeScope(jjtn009);
3420 }
3421 jjtn009.jjtSetLastToken(getToken(0));
3422 }
3423 }
3424 break;
3425 }
3426 case ene:{
3427 jj_consume_token(ene);
3428 ASTNEWNode jjtn010 = new ASTNEWNode(JJTNEWNODE);
3429 boolean jjtc010 = true;
3430 jjtree.openNodeScope(jjtn010);
3431 jjtreeOpenNodeScope(jjtn010);
3432 jjtn010.jjtSetFirstToken(getToken(1));
3433 try {
3434 ShiftExpression();
3435 } catch (Throwable jjte010) {
3436 if (jjtc010) {
3437 jjtree.clearNodeScope(jjtn010);
3438 jjtc010 = false;
3439 } else {
3440 jjtree.popNode();
3441 }
3442 if (jjte010 instanceof ParseException) {
3443 throw (ParseException)jjte010;
3444 }
3445 if (jjte010 instanceof RuntimeException) {
3446 throw (RuntimeException)jjte010;
3447 }
3448 throw (Error)jjte010;
3449 } finally {
3450 if (jjtc010) {
3451 jjtree.closeNodeScope(jjtn010, 2);
3452 if (jjtree.nodeCreated()) {
3453 jjtreeCloseNodeScope(jjtn010);
3454 }
3455 jjtn010.jjtSetLastToken(getToken(0));
3456 }
3457 }
3458 break;
3459 }
3460 case ISA:{
3461 jj_consume_token(ISA);
3462 ASTInstanceOf jjtn011 = new ASTInstanceOf(JJTINSTANCEOF);
3463 boolean jjtc011 = true;
3464 jjtree.openNodeScope(jjtn011);
3465 jjtreeOpenNodeScope(jjtn011);
3466 jjtn011.jjtSetFirstToken(getToken(1));
3467 try {
3468 ShiftExpression();
3469 } catch (Throwable jjte011) {
3470 if (jjtc011) {
3471 jjtree.clearNodeScope(jjtn011);
3472 jjtc011 = false;
3473 } else {
3474 jjtree.popNode();
3475 }
3476 if (jjte011 instanceof ParseException) {
3477 throw (ParseException)jjte011;
3478 }
3479 if (jjte011 instanceof RuntimeException) {
3480 throw (RuntimeException)jjte011;
3481 }
3482 throw (Error)jjte011;
3483 } finally {
3484 if (jjtc011) {
3485 jjtree.closeNodeScope(jjtn011, 2);
3486 if (jjtree.nodeCreated()) {
3487 jjtreeCloseNodeScope(jjtn011);
3488 }
3489 jjtn011.jjtSetLastToken(getToken(0));
3490 }
3491 }
3492 break;
3493 }
3494 case NISA:{
3495 jj_consume_token(NISA);
3496 ASTNotInstanceOf jjtn012 = new ASTNotInstanceOf(JJTNOTINSTANCEOF);
3497 boolean jjtc012 = true;
3498 jjtree.openNodeScope(jjtn012);
3499 jjtreeOpenNodeScope(jjtn012);
3500 jjtn012.jjtSetFirstToken(getToken(1));
3501 try {
3502 ShiftExpression();
3503 } catch (Throwable jjte012) {
3504 if (jjtc012) {
3505 jjtree.clearNodeScope(jjtn012);
3506 jjtc012 = false;
3507 } else {
3508 jjtree.popNode();
3509 }
3510 if (jjte012 instanceof ParseException) {
3511 throw (ParseException)jjte012;
3512 }
3513 if (jjte012 instanceof RuntimeException) {
3514 throw (RuntimeException)jjte012;
3515 }
3516 throw (Error)jjte012;
3517 } finally {
3518 if (jjtc012) {
3519 jjtree.closeNodeScope(jjtn012, 2);
3520 if (jjtree.nodeCreated()) {
3521 jjtreeCloseNodeScope(jjtn012);
3522 }
3523 jjtn012.jjtSetLastToken(getToken(0));
3524 }
3525 }
3526 break;
3527 }
3528 default:
3529 jj_consume_token(-1);
3530 throw new ParseException();
3531 }
3532 } else {
3533 ;
3534 }
3535 }
3536
3537
3538
3539
3540 final public void ShiftExpression() throws ParseException {
3541 AdditiveExpression();
3542 label_24:
3543 while (true) {
3544 if (jj_2_61(2)) {
3545 } else {
3546 break label_24;
3547 }
3548 switch (jj_nt.kind) {
3549 case lshift:{
3550 jj_consume_token(lshift);
3551 ASTShiftLeftNode jjtn001 = new ASTShiftLeftNode(JJTSHIFTLEFTNODE);
3552 boolean jjtc001 = true;
3553 jjtree.openNodeScope(jjtn001);
3554 jjtreeOpenNodeScope(jjtn001);
3555 jjtn001.jjtSetFirstToken(getToken(1));
3556 try {
3557 AdditiveExpression();
3558 } catch (Throwable jjte001) {
3559 if (jjtc001) {
3560 jjtree.clearNodeScope(jjtn001);
3561 jjtc001 = false;
3562 } else {
3563 jjtree.popNode();
3564 }
3565 if (jjte001 instanceof ParseException) {
3566 throw (ParseException)jjte001;
3567 }
3568 if (jjte001 instanceof RuntimeException) {
3569 throw (RuntimeException)jjte001;
3570 }
3571 throw (Error)jjte001;
3572 } finally {
3573 if (jjtc001) {
3574 jjtree.closeNodeScope(jjtn001, 2);
3575 if (jjtree.nodeCreated()) {
3576 jjtreeCloseNodeScope(jjtn001);
3577 }
3578 jjtn001.jjtSetLastToken(getToken(0));
3579 }
3580 }
3581 break;
3582 }
3583 case rshift:{
3584 jj_consume_token(rshift);
3585 ASTShiftRightNode jjtn002 = new ASTShiftRightNode(JJTSHIFTRIGHTNODE);
3586 boolean jjtc002 = true;
3587 jjtree.openNodeScope(jjtn002);
3588 jjtreeOpenNodeScope(jjtn002);
3589 jjtn002.jjtSetFirstToken(getToken(1));
3590 try {
3591 AdditiveExpression();
3592 } catch (Throwable jjte002) {
3593 if (jjtc002) {
3594 jjtree.clearNodeScope(jjtn002);
3595 jjtc002 = false;
3596 } else {
3597 jjtree.popNode();
3598 }
3599 if (jjte002 instanceof ParseException) {
3600 throw (ParseException)jjte002;
3601 }
3602 if (jjte002 instanceof RuntimeException) {
3603 throw (RuntimeException)jjte002;
3604 }
3605 throw (Error)jjte002;
3606 } finally {
3607 if (jjtc002) {
3608 jjtree.closeNodeScope(jjtn002, 2);
3609 if (jjtree.nodeCreated()) {
3610 jjtreeCloseNodeScope(jjtn002);
3611 }
3612 jjtn002.jjtSetLastToken(getToken(0));
3613 }
3614 }
3615 break;
3616 }
3617 case rshiftu:{
3618 jj_consume_token(rshiftu);
3619 ASTShiftRightUnsignedNode jjtn003 = new ASTShiftRightUnsignedNode(JJTSHIFTRIGHTUNSIGNEDNODE);
3620 boolean jjtc003 = true;
3621 jjtree.openNodeScope(jjtn003);
3622 jjtreeOpenNodeScope(jjtn003);
3623 jjtn003.jjtSetFirstToken(getToken(1));
3624 try {
3625 AdditiveExpression();
3626 } catch (Throwable jjte003) {
3627 if (jjtc003) {
3628 jjtree.clearNodeScope(jjtn003);
3629 jjtc003 = false;
3630 } else {
3631 jjtree.popNode();
3632 }
3633 if (jjte003 instanceof ParseException) {
3634 throw (ParseException)jjte003;
3635 }
3636 if (jjte003 instanceof RuntimeException) {
3637 throw (RuntimeException)jjte003;
3638 }
3639 throw (Error)jjte003;
3640 } finally {
3641 if (jjtc003) {
3642 jjtree.closeNodeScope(jjtn003, 2);
3643 if (jjtree.nodeCreated()) {
3644 jjtreeCloseNodeScope(jjtn003);
3645 }
3646 jjtn003.jjtSetLastToken(getToken(0));
3647 }
3648 }
3649 break;
3650 }
3651 default:
3652 jj_consume_token(-1);
3653 throw new ParseException();
3654 }
3655 }
3656 }
3657
3658 final public void AdditiveExpression() throws ParseException {
3659 MultiplicativeExpression();
3660 label_25:
3661 while (true) {
3662 if (jj_2_62(2)) {
3663 } else {
3664 break label_25;
3665 }
3666 switch (jj_nt.kind) {
3667 case plus:{
3668 jj_consume_token(plus);
3669 ASTAddNode jjtn001 = new ASTAddNode(JJTADDNODE);
3670 boolean jjtc001 = true;
3671 jjtree.openNodeScope(jjtn001);
3672 jjtreeOpenNodeScope(jjtn001);
3673 jjtn001.jjtSetFirstToken(getToken(1));
3674 try {
3675 MultiplicativeExpression();
3676 } catch (Throwable jjte001) {
3677 if (jjtc001) {
3678 jjtree.clearNodeScope(jjtn001);
3679 jjtc001 = false;
3680 } else {
3681 jjtree.popNode();
3682 }
3683 if (jjte001 instanceof ParseException) {
3684 throw (ParseException)jjte001;
3685 }
3686 if (jjte001 instanceof RuntimeException) {
3687 throw (RuntimeException)jjte001;
3688 }
3689 throw (Error)jjte001;
3690 } finally {
3691 if (jjtc001) {
3692 jjtree.closeNodeScope(jjtn001, 2);
3693 if (jjtree.nodeCreated()) {
3694 jjtreeCloseNodeScope(jjtn001);
3695 }
3696 jjtn001.jjtSetLastToken(getToken(0));
3697 }
3698 }
3699 break;
3700 }
3701 case minus:{
3702 jj_consume_token(minus);
3703 ASTSubNode jjtn002 = new ASTSubNode(JJTSUBNODE);
3704 boolean jjtc002 = true;
3705 jjtree.openNodeScope(jjtn002);
3706 jjtreeOpenNodeScope(jjtn002);
3707 jjtn002.jjtSetFirstToken(getToken(1));
3708 try {
3709 MultiplicativeExpression();
3710 } catch (Throwable jjte002) {
3711 if (jjtc002) {
3712 jjtree.clearNodeScope(jjtn002);
3713 jjtc002 = false;
3714 } else {
3715 jjtree.popNode();
3716 }
3717 if (jjte002 instanceof ParseException) {
3718 throw (ParseException)jjte002;
3719 }
3720 if (jjte002 instanceof RuntimeException) {
3721 throw (RuntimeException)jjte002;
3722 }
3723 throw (Error)jjte002;
3724 } finally {
3725 if (jjtc002) {
3726 jjtree.closeNodeScope(jjtn002, 2);
3727 if (jjtree.nodeCreated()) {
3728 jjtreeCloseNodeScope(jjtn002);
3729 }
3730 jjtn002.jjtSetLastToken(getToken(0));
3731 }
3732 }
3733 break;
3734 }
3735 default:
3736 jj_consume_token(-1);
3737 throw new ParseException();
3738 }
3739 }
3740 }
3741
3742 final public void MultiplicativeExpression() throws ParseException {
3743 UnaryExpression();
3744 label_26:
3745 while (true) {
3746 if (jj_2_63(2)) {
3747 } else {
3748 break label_26;
3749 }
3750 switch (jj_nt.kind) {
3751 case mult:{
3752 jj_consume_token(mult);
3753 ASTMulNode jjtn001 = new ASTMulNode(JJTMULNODE);
3754 boolean jjtc001 = true;
3755 jjtree.openNodeScope(jjtn001);
3756 jjtreeOpenNodeScope(jjtn001);
3757 jjtn001.jjtSetFirstToken(getToken(1));
3758 try {
3759 UnaryExpression();
3760 } catch (Throwable jjte001) {
3761 if (jjtc001) {
3762 jjtree.clearNodeScope(jjtn001);
3763 jjtc001 = false;
3764 } else {
3765 jjtree.popNode();
3766 }
3767 if (jjte001 instanceof ParseException) {
3768 throw (ParseException)jjte001;
3769 }
3770 if (jjte001 instanceof RuntimeException) {
3771 throw (RuntimeException)jjte001;
3772 }
3773 throw (Error)jjte001;
3774 } finally {
3775 if (jjtc001) {
3776 jjtree.closeNodeScope(jjtn001, 2);
3777 if (jjtree.nodeCreated()) {
3778 jjtreeCloseNodeScope(jjtn001);
3779 }
3780 jjtn001.jjtSetLastToken(getToken(0));
3781 }
3782 }
3783 break;
3784 }
3785 case div:
3786 case DIV:{
3787 switch (jj_nt.kind) {
3788 case div:{
3789 jj_consume_token(div);
3790 break;
3791 }
3792 case DIV:{
3793 jj_consume_token(DIV);
3794 break;
3795 }
3796 default:
3797 jj_consume_token(-1);
3798 throw new ParseException();
3799 }
3800 ASTDivNode jjtn002 = new ASTDivNode(JJTDIVNODE);
3801 boolean jjtc002 = true;
3802 jjtree.openNodeScope(jjtn002);
3803 jjtreeOpenNodeScope(jjtn002);
3804 jjtn002.jjtSetFirstToken(getToken(1));
3805 try {
3806 UnaryExpression();
3807 } catch (Throwable jjte002) {
3808 if (jjtc002) {
3809 jjtree.clearNodeScope(jjtn002);
3810 jjtc002 = false;
3811 } else {
3812 jjtree.popNode();
3813 }
3814 if (jjte002 instanceof ParseException) {
3815 throw (ParseException)jjte002;
3816 }
3817 if (jjte002 instanceof RuntimeException) {
3818 throw (RuntimeException)jjte002;
3819 }
3820 throw (Error)jjte002;
3821 } finally {
3822 if (jjtc002) {
3823 jjtree.closeNodeScope(jjtn002, 2);
3824 if (jjtree.nodeCreated()) {
3825 jjtreeCloseNodeScope(jjtn002);
3826 }
3827 jjtn002.jjtSetLastToken(getToken(0));
3828 }
3829 }
3830 break;
3831 }
3832 case mod:
3833 case MOD:{
3834 switch (jj_nt.kind) {
3835 case mod:{
3836 jj_consume_token(mod);
3837 break;
3838 }
3839 case MOD:{
3840 jj_consume_token(MOD);
3841 break;
3842 }
3843 default:
3844 jj_consume_token(-1);
3845 throw new ParseException();
3846 }
3847 ASTModNode jjtn003 = new ASTModNode(JJTMODNODE);
3848 boolean jjtc003 = true;
3849 jjtree.openNodeScope(jjtn003);
3850 jjtreeOpenNodeScope(jjtn003);
3851 jjtn003.jjtSetFirstToken(getToken(1));
3852 try {
3853 UnaryExpression();
3854 } catch (Throwable jjte003) {
3855 if (jjtc003) {
3856 jjtree.clearNodeScope(jjtn003);
3857 jjtc003 = false;
3858 } else {
3859 jjtree.popNode();
3860 }
3861 if (jjte003 instanceof ParseException) {
3862 throw (ParseException)jjte003;
3863 }
3864 if (jjte003 instanceof RuntimeException) {
3865 throw (RuntimeException)jjte003;
3866 }
3867 throw (Error)jjte003;
3868 } finally {
3869 if (jjtc003) {
3870 jjtree.closeNodeScope(jjtn003, 2);
3871 if (jjtree.nodeCreated()) {
3872 jjtreeCloseNodeScope(jjtn003);
3873 }
3874 jjtn003.jjtSetLastToken(getToken(0));
3875 }
3876 }
3877 break;
3878 }
3879 default:
3880 jj_consume_token(-1);
3881 throw new ParseException();
3882 }
3883 }
3884 }
3885
3886 final public void UnaryExpression() throws ParseException {
3887 switch (jj_nt.kind) {
3888 case minus:{
3889 jj_consume_token(minus);
3890 ASTUnaryMinusNode jjtn001 = new ASTUnaryMinusNode(JJTUNARYMINUSNODE);
3891 boolean jjtc001 = true;
3892 jjtree.openNodeScope(jjtn001);
3893 jjtreeOpenNodeScope(jjtn001);
3894 jjtn001.jjtSetFirstToken(getToken(1));
3895 try {
3896 UnaryExpression();
3897 } catch (Throwable jjte001) {
3898 if (jjtc001) {
3899 jjtree.clearNodeScope(jjtn001);
3900 jjtc001 = false;
3901 } else {
3902 jjtree.popNode();
3903 }
3904 if (jjte001 instanceof ParseException) {
3905 throw (ParseException)jjte001;
3906 }
3907 if (jjte001 instanceof RuntimeException) {
3908 throw (RuntimeException)jjte001;
3909 }
3910 throw (Error)jjte001;
3911 } finally {
3912 if (jjtc001) {
3913 jjtree.closeNodeScope(jjtn001, 1);
3914 if (jjtree.nodeCreated()) {
3915 jjtreeCloseNodeScope(jjtn001);
3916 }
3917 jjtn001.jjtSetLastToken(getToken(0));
3918 }
3919 }
3920 break;
3921 }
3922 case plus:{
3923 jj_consume_token(plus);
3924 ASTUnaryPlusNode jjtn002 = new ASTUnaryPlusNode(JJTUNARYPLUSNODE);
3925 boolean jjtc002 = true;
3926 jjtree.openNodeScope(jjtn002);
3927 jjtreeOpenNodeScope(jjtn002);
3928 jjtn002.jjtSetFirstToken(getToken(1));
3929 try {
3930 UnaryExpression();
3931 } catch (Throwable jjte002) {
3932 if (jjtc002) {
3933 jjtree.clearNodeScope(jjtn002);
3934 jjtc002 = false;
3935 } else {
3936 jjtree.popNode();
3937 }
3938 if (jjte002 instanceof ParseException) {
3939 throw (ParseException)jjte002;
3940 }
3941 if (jjte002 instanceof RuntimeException) {
3942 throw (RuntimeException)jjte002;
3943 }
3944 throw (Error)jjte002;
3945 } finally {
3946 if (jjtc002) {
3947 jjtree.closeNodeScope(jjtn002, 1);
3948 if (jjtree.nodeCreated()) {
3949 jjtreeCloseNodeScope(jjtn002);
3950 }
3951 jjtn002.jjtSetLastToken(getToken(0));
3952 }
3953 }
3954 break;
3955 }
3956 case tilda:{
3957 jj_consume_token(tilda);
3958 ASTBitwiseComplNode jjtn003 = new ASTBitwiseComplNode(JJTBITWISECOMPLNODE);
3959 boolean jjtc003 = true;
3960 jjtree.openNodeScope(jjtn003);
3961 jjtreeOpenNodeScope(jjtn003);
3962 jjtn003.jjtSetFirstToken(getToken(1));
3963 try {
3964 UnaryExpression();
3965 } catch (Throwable jjte003) {
3966 if (jjtc003) {
3967 jjtree.clearNodeScope(jjtn003);
3968 jjtc003 = false;
3969 } else {
3970 jjtree.popNode();
3971 }
3972 if (jjte003 instanceof ParseException) {
3973 throw (ParseException)jjte003;
3974 }
3975 if (jjte003 instanceof RuntimeException) {
3976 throw (RuntimeException)jjte003;
3977 }
3978 throw (Error)jjte003;
3979 } finally {
3980 if (jjtc003) {
3981 jjtree.closeNodeScope(jjtn003, 1);
3982 if (jjtree.nodeCreated()) {
3983 jjtreeCloseNodeScope(jjtn003);
3984 }
3985 jjtn003.jjtSetLastToken(getToken(0));
3986 }
3987 }
3988 break;
3989 }
3990 case not:
3991 case NOT:{
3992 switch (jj_nt.kind) {
3993 case not:{
3994 jj_consume_token(not);
3995 break;
3996 }
3997 case NOT:{
3998 jj_consume_token(NOT);
3999 break;
4000 }
4001 default:
4002 jj_consume_token(-1);
4003 throw new ParseException();
4004 }
4005 ASTNotNode jjtn004 = new ASTNotNode(JJTNOTNODE);
4006 boolean jjtc004 = true;
4007 jjtree.openNodeScope(jjtn004);
4008 jjtreeOpenNodeScope(jjtn004);
4009 jjtn004.jjtSetFirstToken(getToken(1));
4010 try {
4011 UnaryExpression();
4012 } catch (Throwable jjte004) {
4013 if (jjtc004) {
4014 jjtree.clearNodeScope(jjtn004);
4015 jjtc004 = false;
4016 } else {
4017 jjtree.popNode();
4018 }
4019 if (jjte004 instanceof ParseException) {
4020 throw (ParseException)jjte004;
4021 }
4022 if (jjte004 instanceof RuntimeException) {
4023 throw (RuntimeException)jjte004;
4024 }
4025 throw (Error)jjte004;
4026 } finally {
4027 if (jjtc004) {
4028 jjtree.closeNodeScope(jjtn004, 1);
4029 if (jjtree.nodeCreated()) {
4030 jjtreeCloseNodeScope(jjtn004);
4031 }
4032 jjtn004.jjtSetLastToken(getToken(0));
4033 }
4034 }
4035 break;
4036 }
4037 case EMPTY:{
4038 jj_consume_token(EMPTY);
4039 ASTEmptyFunction jjtn005 = new ASTEmptyFunction(JJTEMPTYFUNCTION);
4040 boolean jjtc005 = true;
4041 jjtree.openNodeScope(jjtn005);
4042 jjtreeOpenNodeScope(jjtn005);
4043 jjtn005.jjtSetFirstToken(getToken(1));
4044 try {
4045 UnaryExpression();
4046 } catch (Throwable jjte005) {
4047 if (jjtc005) {
4048 jjtree.clearNodeScope(jjtn005);
4049 jjtc005 = false;
4050 } else {
4051 jjtree.popNode();
4052 }
4053 if (jjte005 instanceof ParseException) {
4054 throw (ParseException)jjte005;
4055 }
4056 if (jjte005 instanceof RuntimeException) {
4057 throw (RuntimeException)jjte005;
4058 }
4059 throw (Error)jjte005;
4060 } finally {
4061 if (jjtc005) {
4062 jjtree.closeNodeScope(jjtn005, 1);
4063 if (jjtree.nodeCreated()) {
4064 jjtreeCloseNodeScope(jjtn005);
4065 }
4066 jjtn005.jjtSetLastToken(getToken(0));
4067 }
4068 }
4069 break;
4070 }
4071 case SIZE:{
4072 jj_consume_token(SIZE);
4073 ASTSizeFunction jjtn006 = new ASTSizeFunction(JJTSIZEFUNCTION);
4074 boolean jjtc006 = true;
4075 jjtree.openNodeScope(jjtn006);
4076 jjtreeOpenNodeScope(jjtn006);
4077 jjtn006.jjtSetFirstToken(getToken(1));
4078 try {
4079 UnaryExpression();
4080 } catch (Throwable jjte006) {
4081 if (jjtc006) {
4082 jjtree.clearNodeScope(jjtn006);
4083 jjtc006 = false;
4084 } else {
4085 jjtree.popNode();
4086 }
4087 if (jjte006 instanceof ParseException) {
4088 throw (ParseException)jjte006;
4089 }
4090 if (jjte006 instanceof RuntimeException) {
4091 throw (RuntimeException)jjte006;
4092 }
4093 throw (Error)jjte006;
4094 } finally {
4095 if (jjtc006) {
4096 jjtree.closeNodeScope(jjtn006, 1);
4097 if (jjtree.nodeCreated()) {
4098 jjtreeCloseNodeScope(jjtn006);
4099 }
4100 jjtn006.jjtSetLastToken(getToken(0));
4101 }
4102 }
4103 break;
4104 }
4105 case minusminus:{
4106 jj_consume_token(minusminus);
4107 ASTDecrementGetNode jjtn007 = new ASTDecrementGetNode(JJTDECREMENTGETNODE);
4108 boolean jjtc007 = true;
4109 jjtree.openNodeScope(jjtn007);
4110 jjtreeOpenNodeScope(jjtn007);
4111 jjtn007.jjtSetFirstToken(getToken(1));
4112 try {
4113 UnaryExpression();
4114 } catch (Throwable jjte007) {
4115 if (jjtc007) {
4116 jjtree.clearNodeScope(jjtn007);
4117 jjtc007 = false;
4118 } else {
4119 jjtree.popNode();
4120 }
4121 if (jjte007 instanceof ParseException) {
4122 throw (ParseException)jjte007;
4123 }
4124 if (jjte007 instanceof RuntimeException) {
4125 throw (RuntimeException)jjte007;
4126 }
4127 throw (Error)jjte007;
4128 } finally {
4129 if (jjtc007) {
4130 jjtree.closeNodeScope(jjtn007, 1);
4131 if (jjtree.nodeCreated()) {
4132 jjtreeCloseNodeScope(jjtn007);
4133 }
4134 jjtn007.jjtSetLastToken(getToken(0));
4135 }
4136 }
4137 break;
4138 }
4139 case plusplus:{
4140 jj_consume_token(plusplus);
4141 ASTIncrementGetNode jjtn008 = new ASTIncrementGetNode(JJTINCREMENTGETNODE);
4142 boolean jjtc008 = true;
4143 jjtree.openNodeScope(jjtn008);
4144 jjtreeOpenNodeScope(jjtn008);
4145 jjtn008.jjtSetFirstToken(getToken(1));
4146 try {
4147 UnaryExpression();
4148 } catch (Throwable jjte008) {
4149 if (jjtc008) {
4150 jjtree.clearNodeScope(jjtn008);
4151 jjtc008 = false;
4152 } else {
4153 jjtree.popNode();
4154 }
4155 if (jjte008 instanceof ParseException) {
4156 throw (ParseException)jjte008;
4157 }
4158 if (jjte008 instanceof RuntimeException) {
4159 throw (RuntimeException)jjte008;
4160 }
4161 throw (Error)jjte008;
4162 } finally {
4163 if (jjtc008) {
4164 jjtree.closeNodeScope(jjtn008, 1);
4165 if (jjtree.nodeCreated()) {
4166 jjtreeCloseNodeScope(jjtn008);
4167 }
4168 jjtn008.jjtSetLastToken(getToken(0));
4169 }
4170 }
4171 break;
4172 }
4173 default:
4174 if (jj_2_64(1)) {
4175 PostfixExpression();
4176 } else {
4177 jj_consume_token(-1);
4178 throw new ParseException();
4179 }
4180 }
4181 }
4182
4183 final public void PostfixOperator() throws ParseException {
4184 switch (jj_nt.kind) {
4185 case plusplus:{
4186 ASTGetIncrementNode jjtn001 = new ASTGetIncrementNode(JJTGETINCREMENTNODE);
4187 boolean jjtc001 = true;
4188 jjtree.openNodeScope(jjtn001);
4189 jjtreeOpenNodeScope(jjtn001);
4190 jjtn001.jjtSetFirstToken(getToken(1));
4191 try {
4192 jj_consume_token(plusplus);
4193 } finally {
4194 if (jjtc001) {
4195 jjtree.closeNodeScope(jjtn001, 1);
4196 if (jjtree.nodeCreated()) {
4197 jjtreeCloseNodeScope(jjtn001);
4198 }
4199 jjtn001.jjtSetLastToken(getToken(0));
4200 }
4201 }
4202 break;
4203 }
4204 case minusminus:{
4205 ASTGetDecrementNode jjtn002 = new ASTGetDecrementNode(JJTGETDECREMENTNODE);
4206 boolean jjtc002 = true;
4207 jjtree.openNodeScope(jjtn002);
4208 jjtreeOpenNodeScope(jjtn002);
4209 jjtn002.jjtSetFirstToken(getToken(1));
4210 try {
4211 jj_consume_token(minusminus);
4212 } finally {
4213 if (jjtc002) {
4214 jjtree.closeNodeScope(jjtn002, 1);
4215 if (jjtree.nodeCreated()) {
4216 jjtreeCloseNodeScope(jjtn002);
4217 }
4218 jjtn002.jjtSetLastToken(getToken(0));
4219 }
4220 }
4221 break;
4222 }
4223 default:
4224 jj_consume_token(-1);
4225 throw new ParseException();
4226 }
4227 }
4228
4229 final public void PostfixExpression() throws ParseException {
4230 ValueExpression();
4231 switch (jj_nt.kind) {
4232 case plusplus:
4233 case minusminus:{
4234 PostfixOperator();
4235 break;
4236 }
4237 default:
4238 ;
4239 }
4240 }
4241
4242
4243
4244
4245 final public
4246 void Identifier(boolean top) throws ParseException {
4247 ASTIdentifier jjtn000 = new ASTIdentifier(JJTIDENTIFIER);
4248 boolean jjtc000 = true;
4249 jjtree.openNodeScope(jjtn000);
4250 jjtreeOpenNodeScope(jjtn000);
4251 jjtn000.jjtSetFirstToken(getToken(1));Token t;
4252 try {
4253 switch (jj_nt.kind) {
4254 case IDENTIFIER:{
4255 t = jj_consume_token(IDENTIFIER);
4256 jjtree.closeNodeScope(jjtn000, true);
4257 jjtc000 = false;
4258 if (jjtree.nodeCreated()) {
4259 jjtreeCloseNodeScope(jjtn000);
4260 }
4261 jjtn000.jjtSetLastToken(getToken(0));
4262 jjtn000.setSymbol(top? checkVariable(jjtn000, t.image) : t.image);
4263 break;
4264 }
4265 case REGISTER:{
4266 t = jj_consume_token(REGISTER);
4267 jjtree.closeNodeScope(jjtn000, true);
4268 jjtc000 = false;
4269 if (jjtree.nodeCreated()) {
4270 jjtreeCloseNodeScope(jjtn000);
4271 }
4272 jjtn000.jjtSetLastToken(getToken(0));
4273 if (!getFeatures().supportsRegister()) throwParsingException(t); jjtn000.setSymbol(t.image);
4274 break;
4275 }
4276 default:
4277 jj_consume_token(-1);
4278 throw new ParseException();
4279 }
4280 } finally {
4281 if (jjtc000) {
4282 jjtree.closeNodeScope(jjtn000, true);
4283 if (jjtree.nodeCreated()) {
4284 jjtreeCloseNodeScope(jjtn000);
4285 }
4286 jjtn000.jjtSetLastToken(getToken(0));
4287 }
4288 }
4289 }
4290
4291 final public void NamespaceIdentifier() throws ParseException {
4292 ASTNamespaceIdentifier jjtn000 = new ASTNamespaceIdentifier(JJTNAMESPACEIDENTIFIER);
4293 boolean jjtc000 = true;
4294 jjtree.openNodeScope(jjtn000);
4295 jjtreeOpenNodeScope(jjtn000);
4296 jjtn000.jjtSetFirstToken(getToken(1));Token ns;
4297 Token id;
4298 try {
4299 ns = jj_consume_token(IDENTIFIER);
4300 jj_consume_token(COLON);
4301 id = jj_consume_token(IDENTIFIER);
4302 jjtree.closeNodeScope(jjtn000, true);
4303 jjtc000 = false;
4304 if (jjtree.nodeCreated()) {
4305 jjtreeCloseNodeScope(jjtn000);
4306 }
4307 jjtn000.jjtSetLastToken(getToken(0));
4308 jjtn000.setNamespace(ns.image, id.image);
4309 } finally {
4310 if (jjtc000) {
4311 jjtree.closeNodeScope(jjtn000, true);
4312 if (jjtree.nodeCreated()) {
4313 jjtreeCloseNodeScope(jjtn000);
4314 }
4315 jjtn000.jjtSetLastToken(getToken(0));
4316 }
4317 }
4318 }
4319
4320 final public void Literal() throws ParseException {Token t;
4321 switch (jj_nt.kind) {
4322 case INTEGER_LITERAL:{
4323 IntegerLiteral();
4324 break;
4325 }
4326 case FLOAT_LITERAL:{
4327 FloatLiteral();
4328 break;
4329 }
4330 case TRUE:
4331 case FALSE:{
4332 BooleanLiteral();
4333 break;
4334 }
4335 case JXLT_LITERAL:{
4336 JxltLiteral();
4337 break;
4338 }
4339 case STRING_LITERAL:{
4340 StringLiteral();
4341 break;
4342 }
4343 case REGEX_LITERAL:{
4344 RegexLiteral();
4345 break;
4346 }
4347 case NULL:{
4348 NullLiteral();
4349 break;
4350 }
4351 case NAN_LITERAL:{
4352 NaNLiteral();
4353 break;
4354 }
4355 default:
4356 jj_consume_token(-1);
4357 throw new ParseException();
4358 }
4359 }
4360
4361 final public void NaNLiteral() throws ParseException {
4362 ASTNumberLiteral jjtn000 = new ASTNumberLiteral(JJTNUMBERLITERAL);
4363 boolean jjtc000 = true;
4364 jjtree.openNodeScope(jjtn000);
4365 jjtreeOpenNodeScope(jjtn000);
4366 jjtn000.jjtSetFirstToken(getToken(1));
4367 try {
4368 jj_consume_token(NAN_LITERAL);
4369 jjtree.closeNodeScope(jjtn000, true);
4370 jjtc000 = false;
4371 if (jjtree.nodeCreated()) {
4372 jjtreeCloseNodeScope(jjtn000);
4373 }
4374 jjtn000.jjtSetLastToken(getToken(0));
4375 jjtn000.setReal("NaN");
4376 } finally {
4377 if (jjtc000) {
4378 jjtree.closeNodeScope(jjtn000, true);
4379 if (jjtree.nodeCreated()) {
4380 jjtreeCloseNodeScope(jjtn000);
4381 }
4382 jjtn000.jjtSetLastToken(getToken(0));
4383 }
4384 }
4385 }
4386
4387 final public void NullLiteral() throws ParseException {
4388 ASTNullLiteral jjtn000 = new ASTNullLiteral(JJTNULLLITERAL);
4389 boolean jjtc000 = true;
4390 jjtree.openNodeScope(jjtn000);
4391 jjtreeOpenNodeScope(jjtn000);
4392 jjtn000.jjtSetFirstToken(getToken(1));
4393 try {
4394 jj_consume_token(NULL);
4395 } finally {
4396 if (jjtc000) {
4397 jjtree.closeNodeScope(jjtn000, true);
4398 if (jjtree.nodeCreated()) {
4399 jjtreeCloseNodeScope(jjtn000);
4400 }
4401 jjtn000.jjtSetLastToken(getToken(0));
4402 }
4403 }
4404 }
4405
4406 final public void BooleanLiteral() throws ParseException {
4407 switch (jj_nt.kind) {
4408 case TRUE:{
4409 ASTTrueNode jjtn001 = new ASTTrueNode(JJTTRUENODE);
4410 boolean jjtc001 = true;
4411 jjtree.openNodeScope(jjtn001);
4412 jjtreeOpenNodeScope(jjtn001);
4413 jjtn001.jjtSetFirstToken(getToken(1));
4414 try {
4415 jj_consume_token(TRUE);
4416 } finally {
4417 if (jjtc001) {
4418 jjtree.closeNodeScope(jjtn001, true);
4419 if (jjtree.nodeCreated()) {
4420 jjtreeCloseNodeScope(jjtn001);
4421 }
4422 jjtn001.jjtSetLastToken(getToken(0));
4423 }
4424 }
4425 break;
4426 }
4427 case FALSE:{
4428 ASTFalseNode jjtn002 = new ASTFalseNode(JJTFALSENODE);
4429 boolean jjtc002 = true;
4430 jjtree.openNodeScope(jjtn002);
4431 jjtreeOpenNodeScope(jjtn002);
4432 jjtn002.jjtSetFirstToken(getToken(1));
4433 try {
4434 jj_consume_token(FALSE);
4435 } finally {
4436 if (jjtc002) {
4437 jjtree.closeNodeScope(jjtn002, true);
4438 if (jjtree.nodeCreated()) {
4439 jjtreeCloseNodeScope(jjtn002);
4440 }
4441 jjtn002.jjtSetLastToken(getToken(0));
4442 }
4443 }
4444 break;
4445 }
4446 default:
4447 jj_consume_token(-1);
4448 throw new ParseException();
4449 }
4450 }
4451
4452 final public void IntegerLiteral() throws ParseException {
4453 ASTNumberLiteral jjtn000 = new ASTNumberLiteral(JJTNUMBERLITERAL);
4454 boolean jjtc000 = true;
4455 jjtree.openNodeScope(jjtn000);
4456 jjtreeOpenNodeScope(jjtn000);
4457 jjtn000.jjtSetFirstToken(getToken(1));Token t;
4458 try {
4459 t = jj_consume_token(INTEGER_LITERAL);
4460 jjtree.closeNodeScope(jjtn000, true);
4461 jjtc000 = false;
4462 if (jjtree.nodeCreated()) {
4463 jjtreeCloseNodeScope(jjtn000);
4464 }
4465 jjtn000.jjtSetLastToken(getToken(0));
4466 jjtn000.setNatural(t.image);
4467 } finally {
4468 if (jjtc000) {
4469 jjtree.closeNodeScope(jjtn000, true);
4470 if (jjtree.nodeCreated()) {
4471 jjtreeCloseNodeScope(jjtn000);
4472 }
4473 jjtn000.jjtSetLastToken(getToken(0));
4474 }
4475 }
4476 }
4477
4478 final public void FloatLiteral() throws ParseException {
4479 ASTNumberLiteral jjtn000 = new ASTNumberLiteral(JJTNUMBERLITERAL);
4480 boolean jjtc000 = true;
4481 jjtree.openNodeScope(jjtn000);
4482 jjtreeOpenNodeScope(jjtn000);
4483 jjtn000.jjtSetFirstToken(getToken(1));Token t;
4484 try {
4485 t = jj_consume_token(FLOAT_LITERAL);
4486 jjtree.closeNodeScope(jjtn000, true);
4487 jjtc000 = false;
4488 if (jjtree.nodeCreated()) {
4489 jjtreeCloseNodeScope(jjtn000);
4490 }
4491 jjtn000.jjtSetLastToken(getToken(0));
4492 jjtn000.setReal(t.image);
4493 } finally {
4494 if (jjtc000) {
4495 jjtree.closeNodeScope(jjtn000, true);
4496 if (jjtree.nodeCreated()) {
4497 jjtreeCloseNodeScope(jjtn000);
4498 }
4499 jjtn000.jjtSetLastToken(getToken(0));
4500 }
4501 }
4502 }
4503
4504 final public void StringLiteral() throws ParseException {
4505 ASTStringLiteral jjtn000 = new ASTStringLiteral(JJTSTRINGLITERAL);
4506 boolean jjtc000 = true;
4507 jjtree.openNodeScope(jjtn000);
4508 jjtreeOpenNodeScope(jjtn000);
4509 jjtn000.jjtSetFirstToken(getToken(1));Token t;
4510 try {
4511 t = jj_consume_token(STRING_LITERAL);
4512 jjtree.closeNodeScope(jjtn000, true);
4513 jjtc000 = false;
4514 if (jjtree.nodeCreated()) {
4515 jjtreeCloseNodeScope(jjtn000);
4516 }
4517 jjtn000.jjtSetLastToken(getToken(0));
4518 jjtn000.setLiteral(Parser.buildString(t.image, true));
4519 } finally {
4520 if (jjtc000) {
4521 jjtree.closeNodeScope(jjtn000, true);
4522 if (jjtree.nodeCreated()) {
4523 jjtreeCloseNodeScope(jjtn000);
4524 }
4525 jjtn000.jjtSetLastToken(getToken(0));
4526 }
4527 }
4528 }
4529
4530 final public void JxltLiteral() throws ParseException {
4531 ASTJxltLiteral jjtn000 = new ASTJxltLiteral(JJTJXLTLITERAL);
4532 boolean jjtc000 = true;
4533 jjtree.openNodeScope(jjtn000);
4534 jjtreeOpenNodeScope(jjtn000);
4535 jjtn000.jjtSetFirstToken(getToken(1));Token t;
4536 String src;
4537 try {
4538 t = jj_consume_token(JXLT_LITERAL);
4539 jjtree.closeNodeScope(jjtn000, true);
4540 jjtc000 = false;
4541 if (jjtree.nodeCreated()) {
4542 jjtreeCloseNodeScope(jjtn000);
4543 }
4544 jjtn000.jjtSetLastToken(getToken(0));
4545 jjtn000.setLiteral(src = Parser.buildString(t.image, true), getScope());
4546 } finally {
4547 if (jjtc000) {
4548 jjtree.closeNodeScope(jjtn000, true);
4549 if (jjtree.nodeCreated()) {
4550 jjtreeCloseNodeScope(jjtn000);
4551 }
4552 jjtn000.jjtSetLastToken(getToken(0));
4553 }
4554 }
4555 }
4556
4557 final public void RegexLiteral() throws ParseException {
4558 ASTRegexLiteral jjtn000 = new ASTRegexLiteral(JJTREGEXLITERAL);
4559 boolean jjtc000 = true;
4560 jjtree.openNodeScope(jjtn000);
4561 jjtreeOpenNodeScope(jjtn000);
4562 jjtn000.jjtSetFirstToken(getToken(1));Token t;
4563 try {
4564 t = jj_consume_token(REGEX_LITERAL);
4565 jjtree.closeNodeScope(jjtn000, true);
4566 jjtc000 = false;
4567 if (jjtree.nodeCreated()) {
4568 jjtreeCloseNodeScope(jjtn000);
4569 }
4570 jjtn000.jjtSetLastToken(getToken(0));
4571 jjtn000.setLiteral(Parser.buildRegex(t.image));
4572 } finally {
4573 if (jjtc000) {
4574 jjtree.closeNodeScope(jjtn000, true);
4575 if (jjtree.nodeCreated()) {
4576 jjtreeCloseNodeScope(jjtn000);
4577 }
4578 jjtn000.jjtSetLastToken(getToken(0));
4579 }
4580 }
4581 }
4582
4583 final public void ExtendedLiteral() throws ParseException {
4584 ASTExtendedLiteral jjtn000 = new ASTExtendedLiteral(JJTEXTENDEDLITERAL);
4585 boolean jjtc000 = true;
4586 jjtree.openNodeScope(jjtn000);
4587 jjtreeOpenNodeScope(jjtn000);
4588 jjtn000.jjtSetFirstToken(getToken(1));
4589 try {
4590 jj_consume_token(ELIPSIS);
4591 } finally {
4592 if (jjtc000) {
4593 jjtree.closeNodeScope(jjtn000, true);
4594 if (jjtree.nodeCreated()) {
4595 jjtreeCloseNodeScope(jjtn000);
4596 }
4597 jjtn000.jjtSetLastToken(getToken(0));
4598 }
4599 }
4600 }
4601
4602 final public void ArrayLiteral() throws ParseException {
4603 ASTArrayLiteral jjtn000 = new ASTArrayLiteral(JJTARRAYLITERAL);
4604 boolean jjtc000 = true;
4605 jjtree.openNodeScope(jjtn000);
4606 jjtreeOpenNodeScope(jjtn000);
4607 jjtn000.jjtSetFirstToken(getToken(1));
4608 try {
4609 jj_consume_token(LBRACKET);
4610 switch (jj_nt.kind) {
4611 case COMMA:
4612 case ELIPSIS:{
4613 switch (jj_nt.kind) {
4614 case COMMA:{
4615 jj_consume_token(COMMA);
4616 break;
4617 }
4618 default:
4619 ;
4620 }
4621 ExtendedLiteral();
4622 break;
4623 }
4624 default:
4625 if (jj_2_66(1)) {
4626 Expression();
4627 label_27:
4628 while (true) {
4629 if (jj_2_65(2)) {
4630 } else {
4631 break label_27;
4632 }
4633 jj_consume_token(COMMA);
4634 Expression();
4635 }
4636 switch (jj_nt.kind) {
4637 case COMMA:{
4638 jj_consume_token(COMMA);
4639 switch (jj_nt.kind) {
4640 case ELIPSIS:{
4641 ExtendedLiteral();
4642 jjtn000.setExtended(true);
4643 break;
4644 }
4645 default:
4646 ;
4647 }
4648 break;
4649 }
4650 default:
4651 ;
4652 }
4653 } else {
4654 ;
4655 }
4656 }
4657 jj_consume_token(RBRACKET);
4658 } catch (Throwable jjte000) {
4659 if (jjtc000) {
4660 jjtree.clearNodeScope(jjtn000);
4661 jjtc000 = false;
4662 } else {
4663 jjtree.popNode();
4664 }
4665 if (jjte000 instanceof ParseException) {
4666 throw (ParseException)jjte000;
4667 }
4668 if (jjte000 instanceof RuntimeException) {
4669 throw (RuntimeException)jjte000;
4670 }
4671 throw (Error)jjte000;
4672 } finally {
4673 if (jjtc000) {
4674 jjtree.closeNodeScope(jjtn000, true);
4675 if (jjtree.nodeCreated()) {
4676 jjtreeCloseNodeScope(jjtn000);
4677 }
4678 jjtn000.jjtSetLastToken(getToken(0));
4679 }
4680 }
4681 }
4682
4683 final public void MapLiteral() throws ParseException {
4684 ASTMapLiteral jjtn000 = new ASTMapLiteral(JJTMAPLITERAL);
4685 boolean jjtc000 = true;
4686 jjtree.openNodeScope(jjtn000);
4687 jjtreeOpenNodeScope(jjtn000);
4688 jjtn000.jjtSetFirstToken(getToken(1));
4689 try {
4690 jj_consume_token(LCURLY);
4691 if (jj_2_68(1)) {
4692 MapEntry();
4693 label_28:
4694 while (true) {
4695 if (jj_2_67(2)) {
4696 } else {
4697 break label_28;
4698 }
4699 jj_consume_token(COMMA);
4700 MapEntry();
4701 }
4702 switch (jj_nt.kind) {
4703 case COMMA:{
4704 jj_consume_token(COMMA);
4705 switch (jj_nt.kind) {
4706 case ELIPSIS:{
4707 ExtendedLiteral();
4708 jjtn000.setExtended(true);
4709 break;
4710 }
4711 default:
4712 ;
4713 }
4714 break;
4715 }
4716 default:
4717 ;
4718 }
4719 } else {
4720 switch (jj_nt.kind) {
4721 case COLON:{
4722 jj_consume_token(COLON);
4723 break;
4724 }
4725 default:
4726 jj_consume_token(-1);
4727 throw new ParseException();
4728 }
4729 }
4730 jj_consume_token(RCURLY);
4731 } catch (Throwable jjte000) {
4732 if (jjtc000) {
4733 jjtree.clearNodeScope(jjtn000);
4734 jjtc000 = false;
4735 } else {
4736 jjtree.popNode();
4737 }
4738 if (jjte000 instanceof ParseException) {
4739 throw (ParseException)jjte000;
4740 }
4741 if (jjte000 instanceof RuntimeException) {
4742 throw (RuntimeException)jjte000;
4743 }
4744 throw (Error)jjte000;
4745 } finally {
4746 if (jjtc000) {
4747 jjtree.closeNodeScope(jjtn000, true);
4748 if (jjtree.nodeCreated()) {
4749 jjtreeCloseNodeScope(jjtn000);
4750 }
4751 jjtn000.jjtSetLastToken(getToken(0));
4752 }
4753 }
4754 }
4755
4756 final public void MapEntry() throws ParseException {
4757 ASTMapEntry jjtn000 = new ASTMapEntry(JJTMAPENTRY);
4758 boolean jjtc000 = true;
4759 jjtree.openNodeScope(jjtn000);
4760 jjtreeOpenNodeScope(jjtn000);
4761 jjtn000.jjtSetFirstToken(getToken(1));
4762 try {
4763 if (jj_2_69(2)) {
4764 Identifier(true);
4765 jj_consume_token(COLON);
4766 Expression();
4767 } else if (jj_2_70(1)) {
4768 Expression();
4769 jj_consume_token(COLON);
4770 Expression();
4771 } else {
4772 jj_consume_token(-1);
4773 throw new ParseException();
4774 }
4775 } catch (Throwable jjte000) {
4776 if (jjtc000) {
4777 jjtree.clearNodeScope(jjtn000);
4778 jjtc000 = false;
4779 } else {
4780 jjtree.popNode();
4781 }
4782 if (jjte000 instanceof ParseException) {
4783 throw (ParseException)jjte000;
4784 }
4785 if (jjte000 instanceof RuntimeException) {
4786 throw (RuntimeException)jjte000;
4787 }
4788 throw (Error)jjte000;
4789 } finally {
4790 if (jjtc000) {
4791 jjtree.closeNodeScope(jjtn000, true);
4792 if (jjtree.nodeCreated()) {
4793 jjtreeCloseNodeScope(jjtn000);
4794 }
4795 jjtn000.jjtSetLastToken(getToken(0));
4796 }
4797 }
4798 }
4799
4800 final public void SetLiteral() throws ParseException {
4801 ASTSetLiteral jjtn000 = new ASTSetLiteral(JJTSETLITERAL);
4802 boolean jjtc000 = true;
4803 jjtree.openNodeScope(jjtn000);
4804 jjtreeOpenNodeScope(jjtn000);
4805 jjtn000.jjtSetFirstToken(getToken(1));
4806 try {
4807 jj_consume_token(LCURLY);
4808 if (jj_2_72(1)) {
4809 Expression();
4810 label_29:
4811 while (true) {
4812 if (jj_2_71(2)) {
4813 } else {
4814 break label_29;
4815 }
4816 jj_consume_token(COMMA);
4817 Expression();
4818 }
4819 switch (jj_nt.kind) {
4820 case COMMA:{
4821 jj_consume_token(COMMA);
4822 switch (jj_nt.kind) {
4823 case ELIPSIS:{
4824 ExtendedLiteral();
4825 jjtn000.setExtended(true);
4826 break;
4827 }
4828 default:
4829 ;
4830 }
4831 break;
4832 }
4833 default:
4834 ;
4835 }
4836 } else {
4837 ;
4838 }
4839 jj_consume_token(RCURLY);
4840 } catch (Throwable jjte000) {
4841 if (jjtc000) {
4842 jjtree.clearNodeScope(jjtn000);
4843 jjtc000 = false;
4844 } else {
4845 jjtree.popNode();
4846 }
4847 if (jjte000 instanceof ParseException) {
4848 throw (ParseException)jjte000;
4849 }
4850 if (jjte000 instanceof RuntimeException) {
4851 throw (RuntimeException)jjte000;
4852 }
4853 throw (Error)jjte000;
4854 } finally {
4855 if (jjtc000) {
4856 jjtree.closeNodeScope(jjtn000, true);
4857 if (jjtree.nodeCreated()) {
4858 jjtreeCloseNodeScope(jjtn000);
4859 }
4860 jjtn000.jjtSetLastToken(getToken(0));
4861 }
4862 }
4863 }
4864
4865
4866
4867
4868 final public
4869 void Arguments() throws ParseException {
4870 ASTArguments jjtn000 = new ASTArguments(JJTARGUMENTS);
4871 boolean jjtc000 = true;
4872 jjtree.openNodeScope(jjtn000);
4873 jjtreeOpenNodeScope(jjtn000);
4874 jjtn000.jjtSetFirstToken(getToken(1));
4875 try {
4876 jj_consume_token(LPAREN);
4877 if (jj_2_73(1)) {
4878 Expression();
4879 label_30:
4880 while (true) {
4881 switch (jj_nt.kind) {
4882 case COMMA:{
4883 break;
4884 }
4885 default:
4886 break label_30;
4887 }
4888 jj_consume_token(COMMA);
4889 Expression();
4890 }
4891 } else {
4892 ;
4893 }
4894 jj_consume_token(RPAREN);
4895 } catch (Throwable jjte000) {
4896 if (jjtc000) {
4897 jjtree.clearNodeScope(jjtn000);
4898 jjtc000 = false;
4899 } else {
4900 jjtree.popNode();
4901 }
4902 if (jjte000 instanceof ParseException) {
4903 throw (ParseException)jjte000;
4904 }
4905 if (jjte000 instanceof RuntimeException) {
4906 throw (RuntimeException)jjte000;
4907 }
4908 throw (Error)jjte000;
4909 } finally {
4910 if (jjtc000) {
4911 jjtree.closeNodeScope(jjtn000, true);
4912 if (jjtree.nodeCreated()) {
4913 jjtreeCloseNodeScope(jjtn000);
4914 }
4915 jjtn000.jjtSetLastToken(getToken(0));
4916 }
4917 }
4918 }
4919
4920 final public void FunctionCallLookahead() throws ParseException {
4921 if (jj_2_74(4) && (isNamespaceFuncall(getToken(1), getToken(2), getToken(3), getToken(4)))) {
4922 jj_consume_token(IDENTIFIER);
4923 jj_consume_token(COLON);
4924 jj_consume_token(IDENTIFIER);
4925 jj_consume_token(LPAREN);
4926 } else if (jj_2_75(2)) {
4927 jj_consume_token(IDENTIFIER);
4928 jj_consume_token(LPAREN);
4929 } else if (jj_2_76(2)) {
4930 jj_consume_token(REGISTER);
4931 jj_consume_token(LPAREN);
4932 } else {
4933 jj_consume_token(-1);
4934 throw new ParseException();
4935 }
4936 }
4937
4938 final public void FunctionCall() throws ParseException {
4939 if (jj_2_77(4) && (isNamespaceFuncall(getToken(1), getToken(2), getToken(3), getToken(4)))) {
4940 NamespaceIdentifier();
4941 ASTFunctionNode jjtn001 = new ASTFunctionNode(JJTFUNCTIONNODE);
4942 boolean jjtc001 = true;
4943 jjtree.openNodeScope(jjtn001);
4944 jjtreeOpenNodeScope(jjtn001);
4945 jjtn001.jjtSetFirstToken(getToken(1));
4946 try {
4947 Arguments();
4948 } catch (Throwable jjte001) {
4949 if (jjtc001) {
4950 jjtree.clearNodeScope(jjtn001);
4951 jjtc001 = false;
4952 } else {
4953 jjtree.popNode();
4954 }
4955 if (jjte001 instanceof ParseException) {
4956 throw (ParseException)jjte001;
4957 }
4958 if (jjte001 instanceof RuntimeException) {
4959 throw (RuntimeException)jjte001;
4960 }
4961 throw (Error)jjte001;
4962 } finally {
4963 if (jjtc001) {
4964 jjtree.closeNodeScope(jjtn001, 2);
4965 if (jjtree.nodeCreated()) {
4966 jjtreeCloseNodeScope(jjtn001);
4967 }
4968 jjtn001.jjtSetLastToken(getToken(0));
4969 }
4970 }
4971 } else if (jj_2_78(2147483647)) {
4972 Identifier(true);
4973 ASTFunctionNode jjtn002 = new ASTFunctionNode(JJTFUNCTIONNODE);
4974 boolean jjtc002 = true;
4975 jjtree.openNodeScope(jjtn002);
4976 jjtreeOpenNodeScope(jjtn002);
4977 jjtn002.jjtSetFirstToken(getToken(1));
4978 try {
4979 Arguments();
4980 } catch (Throwable jjte002) {
4981 if (jjtc002) {
4982 jjtree.clearNodeScope(jjtn002);
4983 jjtc002 = false;
4984 } else {
4985 jjtree.popNode();
4986 }
4987 if (jjte002 instanceof ParseException) {
4988 throw (ParseException)jjte002;
4989 }
4990 if (jjte002 instanceof RuntimeException) {
4991 throw (RuntimeException)jjte002;
4992 }
4993 throw (Error)jjte002;
4994 } finally {
4995 if (jjtc002) {
4996 jjtree.closeNodeScope(jjtn002, 2);
4997 if (jjtree.nodeCreated()) {
4998 jjtreeCloseNodeScope(jjtn002);
4999 }
5000 jjtn002.jjtSetLastToken(getToken(0));
5001 }
5002 }
5003 } else {
5004 jj_consume_token(-1);
5005 throw new ParseException();
5006 }
5007 }
5008
5009 final public void QualifiedIdentifier() throws ParseException {
5010 ASTQualifiedIdentifier jjtn000 = new ASTQualifiedIdentifier(JJTQUALIFIEDIDENTIFIER);
5011 boolean jjtc000 = true;
5012 jjtree.openNodeScope(jjtn000);
5013 jjtreeOpenNodeScope(jjtn000);
5014 jjtn000.jjtSetFirstToken(getToken(1));LinkedList<String> lstr = new LinkedList<String>();
5015 try {
5016 propertyKey(lstr);
5017 jjtree.closeNodeScope(jjtn000, true);
5018 jjtc000 = false;
5019 if (jjtree.nodeCreated()) {
5020 jjtreeCloseNodeScope(jjtn000);
5021 }
5022 jjtn000.jjtSetLastToken(getToken(0));
5023 jjtn000.setName(stringify(lstr));
5024 } catch (Throwable jjte000) {
5025 if (jjtc000) {
5026 jjtree.clearNodeScope(jjtn000);
5027 jjtc000 = false;
5028 } else {
5029 jjtree.popNode();
5030 }
5031 if (jjte000 instanceof ParseException) {
5032 throw (ParseException)jjte000;
5033 }
5034 if (jjte000 instanceof RuntimeException) {
5035 throw (RuntimeException)jjte000;
5036 }
5037 throw (Error)jjte000;
5038 } finally {
5039 if (jjtc000) {
5040 jjtree.closeNodeScope(jjtn000, true);
5041 if (jjtree.nodeCreated()) {
5042 jjtreeCloseNodeScope(jjtn000);
5043 }
5044 jjtn000.jjtSetLastToken(getToken(0));
5045 }
5046 }
5047 }
5048
5049 final public void Constructor() throws ParseException {
5050 ASTConstructorNode jjtn000 = new ASTConstructorNode(JJTCONSTRUCTORNODE);
5051 boolean jjtc000 = true;
5052 jjtree.openNodeScope(jjtn000);
5053 jjtreeOpenNodeScope(jjtn000);
5054 jjtn000.jjtSetFirstToken(getToken(1));
5055 try {
5056 if (jj_2_80(2)) {
5057 jj_consume_token(NEW);
5058 jj_consume_token(LPAREN);
5059 Expression();
5060 label_31:
5061 while (true) {
5062 switch (jj_nt.kind) {
5063 case COMMA:{
5064 break;
5065 }
5066 default:
5067 break label_31;
5068 }
5069 jj_consume_token(COMMA);
5070 Expression();
5071 }
5072 jj_consume_token(RPAREN);
5073 } else {
5074 switch (jj_nt.kind) {
5075 case NEW:{
5076 jj_consume_token(NEW);
5077 QualifiedIdentifier();
5078 jj_consume_token(LPAREN);
5079 if (jj_2_79(1)) {
5080 Expression();
5081 label_32:
5082 while (true) {
5083 switch (jj_nt.kind) {
5084 case COMMA:{
5085 break;
5086 }
5087 default:
5088 break label_32;
5089 }
5090 jj_consume_token(COMMA);
5091 Expression();
5092 }
5093 } else {
5094 ;
5095 }
5096 jj_consume_token(RPAREN);
5097 break;
5098 }
5099 default:
5100 jj_consume_token(-1);
5101 throw new ParseException();
5102 }
5103 }
5104 } catch (Throwable jjte000) {
5105 if (jjtc000) {
5106 jjtree.clearNodeScope(jjtn000);
5107 jjtc000 = false;
5108 } else {
5109 jjtree.popNode();
5110 }
5111 if (jjte000 instanceof ParseException) {
5112 throw (ParseException)jjte000;
5113 }
5114 if (jjte000 instanceof RuntimeException) {
5115 throw (RuntimeException)jjte000;
5116 }
5117 throw (Error)jjte000;
5118 } finally {
5119 if (jjtc000) {
5120 jjtree.closeNodeScope(jjtn000, true);
5121 if (jjtree.nodeCreated()) {
5122 jjtreeCloseNodeScope(jjtn000);
5123 }
5124 jjtn000.jjtSetLastToken(getToken(0));
5125 }
5126 }
5127 }
5128
5129 final public void Parameter() throws ParseException {Token t;
5130 switch (jj_nt.kind) {
5131 case VAR:
5132 case IDENTIFIER:{
5133 switch (jj_nt.kind) {
5134 case VAR:{
5135 jj_consume_token(VAR);
5136 break;
5137 }
5138 default:
5139 ;
5140 }
5141 t = jj_consume_token(IDENTIFIER);
5142 declareParameter(t, false, false);
5143 break;
5144 }
5145 case LET:{
5146 jj_consume_token(LET);
5147 t = jj_consume_token(IDENTIFIER);
5148 declareParameter(t, true, false);
5149 break;
5150 }
5151 case CONST:{
5152 jj_consume_token(CONST);
5153 t = jj_consume_token(IDENTIFIER);
5154 declareParameter(t, true, true);
5155 break;
5156 }
5157 default:
5158 jj_consume_token(-1);
5159 throw new ParseException();
5160 }
5161 }
5162
5163 final public void Parameters() throws ParseException {
5164 jj_consume_token(LPAREN);
5165 switch (jj_nt.kind) {
5166 case VAR:
5167 case LET:
5168 case CONST:
5169 case IDENTIFIER:{
5170 Parameter();
5171 label_33:
5172 while (true) {
5173 switch (jj_nt.kind) {
5174 case COMMA:{
5175 break;
5176 }
5177 default:
5178 break label_33;
5179 }
5180 jj_consume_token(COMMA);
5181 Parameter();
5182 }
5183 break;
5184 }
5185 default:
5186 ;
5187 }
5188 jj_consume_token(RPAREN);
5189 }
5190
5191 final public void ParametersLookahead() throws ParseException {
5192 jj_consume_token(LPAREN);
5193 switch (jj_nt.kind) {
5194 case VAR:
5195 case LET:
5196 case CONST:
5197 case IDENTIFIER:{
5198 switch (jj_nt.kind) {
5199 case VAR:
5200 case LET:
5201 case CONST:{
5202 switch (jj_nt.kind) {
5203 case VAR:{
5204 jj_consume_token(VAR);
5205 break;
5206 }
5207 case LET:{
5208 jj_consume_token(LET);
5209 break;
5210 }
5211 case CONST:{
5212 jj_consume_token(CONST);
5213 break;
5214 }
5215 default:
5216 jj_consume_token(-1);
5217 throw new ParseException();
5218 }
5219 break;
5220 }
5221 default:
5222 ;
5223 }
5224 jj_consume_token(IDENTIFIER);
5225 label_34:
5226 while (true) {
5227 switch (jj_nt.kind) {
5228 case COMMA:{
5229 break;
5230 }
5231 default:
5232 break label_34;
5233 }
5234 jj_consume_token(COMMA);
5235 switch (jj_nt.kind) {
5236 case VAR:
5237 case LET:
5238 case CONST:{
5239 switch (jj_nt.kind) {
5240 case VAR:{
5241 jj_consume_token(VAR);
5242 break;
5243 }
5244 case LET:{
5245 jj_consume_token(LET);
5246 break;
5247 }
5248 case CONST:{
5249 jj_consume_token(CONST);
5250 break;
5251 }
5252 default:
5253 jj_consume_token(-1);
5254 throw new ParseException();
5255 }
5256 break;
5257 }
5258 default:
5259 ;
5260 }
5261 jj_consume_token(IDENTIFIER);
5262 }
5263 break;
5264 }
5265 default:
5266 ;
5267 }
5268 jj_consume_token(RPAREN);
5269 }
5270
5271 final public void LambdaLookahead() throws ParseException {
5272 switch (jj_nt.kind) {
5273 case FUNCTION:{
5274 jj_consume_token(FUNCTION);
5275 ParametersLookahead();
5276 break;
5277 }
5278 case LPAREN:{
5279 ParametersLookahead();
5280 switch (jj_nt.kind) {
5281 case LAMBDA:{
5282 jj_consume_token(LAMBDA);
5283 break;
5284 }
5285 case FATARROW:{
5286 jj_consume_token(FATARROW);
5287 break;
5288 }
5289 default:
5290 jj_consume_token(-1);
5291 throw new ParseException();
5292 }
5293 break;
5294 }
5295 case IDENTIFIER:{
5296 jj_consume_token(IDENTIFIER);
5297 switch (jj_nt.kind) {
5298 case LAMBDA:{
5299 jj_consume_token(LAMBDA);
5300 break;
5301 }
5302 case FATARROW:{
5303 jj_consume_token(FATARROW);
5304 break;
5305 }
5306 default:
5307 jj_consume_token(-1);
5308 throw new ParseException();
5309 }
5310 break;
5311 }
5312 default:
5313 jj_consume_token(-1);
5314 throw new ParseException();
5315 }
5316 }
5317
5318 final public void Lambda() throws ParseException {
5319 ASTJexlLambda jjtn000 = new ASTJexlLambda(JJTJEXLLAMBDA);
5320 boolean jjtc000 = true;
5321 jjtree.openNodeScope(jjtn000);
5322 jjtreeOpenNodeScope(jjtn000);
5323 jjtn000.jjtSetFirstToken(getToken(1));Token arrow;
5324 try {
5325 switch (jj_nt.kind) {
5326 case FUNCTION:{
5327 jj_consume_token(FUNCTION);
5328 if (jj_2_81(2147483647)) {
5329 DeclareFunction();
5330 } else {
5331 ;
5332 }
5333 beginLambda(jjtn000);
5334 Parameters();
5335 if (jj_2_82(3)) {
5336 Block();
5337 } else if (jj_2_83(1)) {
5338 Expression();
5339 } else {
5340 jj_consume_token(-1);
5341 throw new ParseException();
5342 }
5343 jjtree.closeNodeScope(jjtn000, true);
5344 jjtc000 = false;
5345 if (jjtree.nodeCreated()) {
5346 jjtreeCloseNodeScope(jjtn000);
5347 }
5348 jjtn000.jjtSetLastToken(getToken(0));
5349 endLambda(jjtn000);
5350 break;
5351 }
5352 case LPAREN:{
5353 beginLambda(jjtn000);
5354 Parameters();
5355 switch (jj_nt.kind) {
5356 case LAMBDA:{
5357 arrow = jj_consume_token(LAMBDA);
5358 break;
5359 }
5360 case FATARROW:{
5361 arrow = jj_consume_token(FATARROW);
5362 break;
5363 }
5364 default:
5365 jj_consume_token(-1);
5366 throw new ParseException();
5367 }
5368 if (jj_2_84(3)) {
5369 Block();
5370 } else if (jj_2_85(1)) {
5371 Expression();
5372 } else {
5373 jj_consume_token(-1);
5374 throw new ParseException();
5375 }
5376 jjtree.closeNodeScope(jjtn000, true);
5377 jjtc000 = false;
5378 if (jjtree.nodeCreated()) {
5379 jjtreeCloseNodeScope(jjtn000);
5380 }
5381 jjtn000.jjtSetLastToken(getToken(0));
5382 checkLambda(arrow); endLambda(jjtn000);
5383 break;
5384 }
5385 case VAR:
5386 case LET:
5387 case CONST:
5388 case IDENTIFIER:{
5389 beginLambda(jjtn000);
5390 Parameter();
5391 switch (jj_nt.kind) {
5392 case LAMBDA:{
5393 arrow = jj_consume_token(LAMBDA);
5394 break;
5395 }
5396 case FATARROW:{
5397 arrow = jj_consume_token(FATARROW);
5398 break;
5399 }
5400 default:
5401 jj_consume_token(-1);
5402 throw new ParseException();
5403 }
5404 if (jj_2_86(3)) {
5405 Block();
5406 } else if (jj_2_87(1)) {
5407 Expression();
5408 } else {
5409 jj_consume_token(-1);
5410 throw new ParseException();
5411 }
5412 jjtree.closeNodeScope(jjtn000, true);
5413 jjtc000 = false;
5414 if (jjtree.nodeCreated()) {
5415 jjtreeCloseNodeScope(jjtn000);
5416 }
5417 jjtn000.jjtSetLastToken(getToken(0));
5418 checkLambda(arrow); endLambda(jjtn000);
5419 break;
5420 }
5421 default:
5422 jj_consume_token(-1);
5423 throw new ParseException();
5424 }
5425 } catch (Throwable jjte000) {
5426 if (jjtc000) {
5427 jjtree.clearNodeScope(jjtn000);
5428 jjtc000 = false;
5429 } else {
5430 jjtree.popNode();
5431 }
5432 if (jjte000 instanceof ParseException) {
5433 throw (ParseException)jjte000;
5434 }
5435 if (jjte000 instanceof RuntimeException) {
5436 throw (RuntimeException)jjte000;
5437 }
5438 throw (Error)jjte000;
5439 } finally {
5440 if (jjtc000) {
5441 jjtree.closeNodeScope(jjtn000, true);
5442 if (jjtree.nodeCreated()) {
5443 jjtreeCloseNodeScope(jjtn000);
5444 }
5445 jjtn000.jjtSetLastToken(getToken(0));
5446 }
5447 }
5448 }
5449
5450
5451
5452
5453 final public
5454 void IdentifierAccess() throws ParseException {Token t;
5455 switch (jj_nt.kind) {
5456 case DOT:{
5457 jj_consume_token(DOT);
5458 switch (jj_nt.kind) {
5459 case DOT_IDENTIFIER:{
5460 t = jj_consume_token(DOT_IDENTIFIER);
5461 ASTIdentifierAccess jjtn001 = new ASTIdentifierAccess(JJTIDENTIFIERACCESS);
5462 boolean jjtc001 = true;
5463 jjtree.openNodeScope(jjtn001);
5464 jjtreeOpenNodeScope(jjtn001);
5465 jjtn001.jjtSetFirstToken(getToken(1));
5466 try {
5467 jjtree.closeNodeScope(jjtn001, true);
5468 jjtc001 = false;
5469 if (jjtree.nodeCreated()) {
5470 jjtreeCloseNodeScope(jjtn001);
5471 }
5472 jjtn001.jjtSetLastToken(getToken(0));
5473 jjtn001.setIdentifier(t.image);
5474 } finally {
5475 if (jjtc001) {
5476 jjtree.closeNodeScope(jjtn001, true);
5477 if (jjtree.nodeCreated()) {
5478 jjtreeCloseNodeScope(jjtn001);
5479 }
5480 jjtn001.jjtSetLastToken(getToken(0));
5481 }
5482 }
5483 break;
5484 }
5485 case STRING_LITERAL:{
5486 t = jj_consume_token(STRING_LITERAL);
5487 ASTIdentifierAccess jjtn002 = new ASTIdentifierAccess(JJTIDENTIFIERACCESS);
5488 boolean jjtc002 = true;
5489 jjtree.openNodeScope(jjtn002);
5490 jjtreeOpenNodeScope(jjtn002);
5491 jjtn002.jjtSetFirstToken(getToken(1));
5492 try {
5493 jjtree.closeNodeScope(jjtn002, true);
5494 jjtc002 = false;
5495 if (jjtree.nodeCreated()) {
5496 jjtreeCloseNodeScope(jjtn002);
5497 }
5498 jjtn002.jjtSetLastToken(getToken(0));
5499 jjtn002.setIdentifier(Parser.buildString(t.image, true));
5500 } finally {
5501 if (jjtc002) {
5502 jjtree.closeNodeScope(jjtn002, true);
5503 if (jjtree.nodeCreated()) {
5504 jjtreeCloseNodeScope(jjtn002);
5505 }
5506 jjtn002.jjtSetLastToken(getToken(0));
5507 }
5508 }
5509 break;
5510 }
5511 case JXLT_LITERAL:{
5512 t = jj_consume_token(JXLT_LITERAL);
5513 ASTIdentifierAccessJxlt jjtn003 = new ASTIdentifierAccessJxlt(JJTIDENTIFIERACCESSJXLT);
5514 boolean jjtc003 = true;
5515 jjtree.openNodeScope(jjtn003);
5516 jjtreeOpenNodeScope(jjtn003);
5517 jjtn003.jjtSetFirstToken(getToken(1));
5518 try {
5519 jjtree.closeNodeScope(jjtn003, true);
5520 jjtc003 = false;
5521 if (jjtree.nodeCreated()) {
5522 jjtreeCloseNodeScope(jjtn003);
5523 }
5524 jjtn003.jjtSetLastToken(getToken(0));
5525 jjtn003.setIdentifier(Parser.buildString(t.image, true), getScope());
5526 } finally {
5527 if (jjtc003) {
5528 jjtree.closeNodeScope(jjtn003, true);
5529 if (jjtree.nodeCreated()) {
5530 jjtreeCloseNodeScope(jjtn003);
5531 }
5532 jjtn003.jjtSetLastToken(getToken(0));
5533 }
5534 }
5535 break;
5536 }
5537 default:
5538 jj_consume_token(-1);
5539 throw new ParseException();
5540 }
5541 break;
5542 }
5543 case QDOT:{
5544 jj_consume_token(QDOT);
5545 switch (jj_nt.kind) {
5546 case DOT_IDENTIFIER:{
5547 t = jj_consume_token(DOT_IDENTIFIER);
5548 ASTIdentifierAccessSafe jjtn004 = new ASTIdentifierAccessSafe(JJTIDENTIFIERACCESSSAFE);
5549 boolean jjtc004 = true;
5550 jjtree.openNodeScope(jjtn004);
5551 jjtreeOpenNodeScope(jjtn004);
5552 jjtn004.jjtSetFirstToken(getToken(1));
5553 try {
5554 jjtree.closeNodeScope(jjtn004, true);
5555 jjtc004 = false;
5556 if (jjtree.nodeCreated()) {
5557 jjtreeCloseNodeScope(jjtn004);
5558 }
5559 jjtn004.jjtSetLastToken(getToken(0));
5560 jjtn004.setIdentifier(t.image);
5561 } finally {
5562 if (jjtc004) {
5563 jjtree.closeNodeScope(jjtn004, true);
5564 if (jjtree.nodeCreated()) {
5565 jjtreeCloseNodeScope(jjtn004);
5566 }
5567 jjtn004.jjtSetLastToken(getToken(0));
5568 }
5569 }
5570 break;
5571 }
5572 case STRING_LITERAL:{
5573 t = jj_consume_token(STRING_LITERAL);
5574 ASTIdentifierAccessSafe jjtn005 = new ASTIdentifierAccessSafe(JJTIDENTIFIERACCESSSAFE);
5575 boolean jjtc005 = true;
5576 jjtree.openNodeScope(jjtn005);
5577 jjtreeOpenNodeScope(jjtn005);
5578 jjtn005.jjtSetFirstToken(getToken(1));
5579 try {
5580 jjtree.closeNodeScope(jjtn005, true);
5581 jjtc005 = false;
5582 if (jjtree.nodeCreated()) {
5583 jjtreeCloseNodeScope(jjtn005);
5584 }
5585 jjtn005.jjtSetLastToken(getToken(0));
5586 jjtn005.setIdentifier(Parser.buildString(t.image, true));
5587 } finally {
5588 if (jjtc005) {
5589 jjtree.closeNodeScope(jjtn005, true);
5590 if (jjtree.nodeCreated()) {
5591 jjtreeCloseNodeScope(jjtn005);
5592 }
5593 jjtn005.jjtSetLastToken(getToken(0));
5594 }
5595 }
5596 break;
5597 }
5598 case JXLT_LITERAL:{
5599 t = jj_consume_token(JXLT_LITERAL);
5600 ASTIdentifierAccessSafeJxlt jjtn006 = new ASTIdentifierAccessSafeJxlt(JJTIDENTIFIERACCESSSAFEJXLT);
5601 boolean jjtc006 = true;
5602 jjtree.openNodeScope(jjtn006);
5603 jjtreeOpenNodeScope(jjtn006);
5604 jjtn006.jjtSetFirstToken(getToken(1));
5605 try {
5606 jjtree.closeNodeScope(jjtn006, true);
5607 jjtc006 = false;
5608 if (jjtree.nodeCreated()) {
5609 jjtreeCloseNodeScope(jjtn006);
5610 }
5611 jjtn006.jjtSetLastToken(getToken(0));
5612 jjtn006.setIdentifier(Parser.buildString(t.image, true), getScope());
5613 } finally {
5614 if (jjtc006) {
5615 jjtree.closeNodeScope(jjtn006, true);
5616 if (jjtree.nodeCreated()) {
5617 jjtreeCloseNodeScope(jjtn006);
5618 }
5619 jjtn006.jjtSetLastToken(getToken(0));
5620 }
5621 }
5622 break;
5623 }
5624 default:
5625 jj_consume_token(-1);
5626 throw new ParseException();
5627 }
5628 break;
5629 }
5630 default:
5631 jj_consume_token(-1);
5632 throw new ParseException();
5633 }
5634 }
5635
5636 final public void ArrayAccess() throws ParseException {
5637 ASTArrayAccess jjtn000 = new ASTArrayAccess(JJTARRAYACCESS);
5638 boolean jjtc000 = true;
5639 jjtree.openNodeScope(jjtn000);
5640 jjtreeOpenNodeScope(jjtn000);
5641 jjtn000.jjtSetFirstToken(getToken(1));long safe = 0L;
5642 int s = 0;
5643 try {
5644 label_35:
5645 while (true) {
5646 switch (jj_nt.kind) {
5647 case LBRACKET:{
5648 jj_consume_token(LBRACKET);
5649 break;
5650 }
5651 case QLBRACKET:{
5652 jj_consume_token(QLBRACKET);
5653 safe |= (1L << s++);
5654 break;
5655 }
5656 default:
5657 jj_consume_token(-1);
5658 throw new ParseException();
5659 }
5660 Expression();
5661 jj_consume_token(RBRACKET);
5662 if (jj_2_88(2)) {
5663 } else {
5664 break label_35;
5665 }
5666 }
5667 jjtree.closeNodeScope(jjtn000, true);
5668 jjtc000 = false;
5669 if (jjtree.nodeCreated()) {
5670 jjtreeCloseNodeScope(jjtn000);
5671 }
5672 jjtn000.jjtSetLastToken(getToken(0));
5673 jjtn000.setSafe(safe);
5674 } catch (Throwable jjte000) {
5675 if (jjtc000) {
5676 jjtree.clearNodeScope(jjtn000);
5677 jjtc000 = false;
5678 } else {
5679 jjtree.popNode();
5680 }
5681 if (jjte000 instanceof ParseException) {
5682 throw (ParseException)jjte000;
5683 }
5684 if (jjte000 instanceof RuntimeException) {
5685 throw (RuntimeException)jjte000;
5686 }
5687 throw (Error)jjte000;
5688 } finally {
5689 if (jjtc000) {
5690 jjtree.closeNodeScope(jjtn000, true);
5691 if (jjtree.nodeCreated()) {
5692 jjtreeCloseNodeScope(jjtn000);
5693 }
5694 jjtn000.jjtSetLastToken(getToken(0));
5695 }
5696 }
5697 }
5698
5699 final public void MemberAccess() throws ParseException {
5700 if (jj_2_89(2147483647)) {
5701 ArrayAccess();
5702 } else if (jj_2_90(2147483647)) {
5703 IdentifierAccess();
5704 } else if (jj_2_91(2147483647)) {
5705 IdentifierAccess();
5706 } else {
5707 jj_consume_token(-1);
5708 throw new ParseException();
5709 }
5710 }
5711
5712 final public void ReferenceExpression() throws ParseException {
5713 ASTMethodNode jjtn000 = new ASTMethodNode(JJTMETHODNODE);
5714 boolean jjtc000 = true;
5715 jjtree.openNodeScope(jjtn000);
5716 jjtreeOpenNodeScope(jjtn000);
5717 jjtn000.jjtSetFirstToken(getToken(1));
5718 try {
5719 jj_consume_token(LPAREN);
5720 Expression();
5721 ASTReferenceExpression jjtn001 = new ASTReferenceExpression(JJTREFERENCEEXPRESSION);
5722 boolean jjtc001 = true;
5723 jjtree.openNodeScope(jjtn001);
5724 jjtreeOpenNodeScope(jjtn001);
5725 jjtn001.jjtSetFirstToken(getToken(1));
5726 try {
5727 jj_consume_token(RPAREN);
5728 } finally {
5729 if (jjtc001) {
5730 jjtree.closeNodeScope(jjtn001, 1);
5731 if (jjtree.nodeCreated()) {
5732 jjtreeCloseNodeScope(jjtn001);
5733 }
5734 jjtn001.jjtSetLastToken(getToken(0));
5735 }
5736 }
5737 label_36:
5738 while (true) {
5739 if (jj_2_92(2147483647)) {
5740 } else {
5741 break label_36;
5742 }
5743 Arguments();
5744 }
5745 } catch (Throwable jjte000) {
5746 if (jjtc000) {
5747 jjtree.clearNodeScope(jjtn000);
5748 jjtc000 = false;
5749 } else {
5750 jjtree.popNode();
5751 }
5752 if (jjte000 instanceof ParseException) {
5753 throw (ParseException)jjte000;
5754 }
5755 if (jjte000 instanceof RuntimeException) {
5756 throw (RuntimeException)jjte000;
5757 }
5758 throw (Error)jjte000;
5759 } finally {
5760 if (jjtc000) {
5761 jjtree.closeNodeScope(jjtn000, jjtree.nodeArity() > 1);
5762 if (jjtree.nodeCreated()) {
5763 jjtreeCloseNodeScope(jjtn000);
5764 }
5765 jjtn000.jjtSetLastToken(getToken(0));
5766 }
5767 }
5768 }
5769
5770 final public void PrimaryExpression() throws ParseException {
5771 if (jj_2_93(2147483647)) {
5772 Lambda();
5773 } else if (jj_2_94(2147483647)) {
5774 ReferenceExpression();
5775 } else if (jj_2_95(2147483647)) {
5776 MapLiteral();
5777 } else if (jj_2_96(2147483647)) {
5778 MapLiteral();
5779 } else if (jj_2_97(2147483647)) {
5780 SetLiteral();
5781 } else if (jj_2_98(2147483647)) {
5782 SetLiteral();
5783 } else if (jj_2_99(2147483647)) {
5784 ArrayLiteral();
5785 } else if (jj_2_100(2147483647)) {
5786 Constructor();
5787 } else if (jj_2_101(2147483647)) {
5788 SwitchExpression();
5789 } else if (jj_2_102(2147483647)) {
5790 FunctionCall();
5791 } else {
5792 switch (jj_nt.kind) {
5793 case IDENTIFIER:
5794 case REGISTER:{
5795 Identifier(true);
5796 break;
5797 }
5798 case NULL:
5799 case TRUE:
5800 case FALSE:
5801 case NAN_LITERAL:
5802 case INTEGER_LITERAL:
5803 case FLOAT_LITERAL:
5804 case STRING_LITERAL:
5805 case JXLT_LITERAL:
5806 case REGEX_LITERAL:{
5807 Literal();
5808 break;
5809 }
5810 default:
5811 jj_consume_token(-1);
5812 throw new ParseException();
5813 }
5814 }
5815 }
5816
5817 final public void MethodCall() throws ParseException {
5818 ASTMethodNode jjtn001 = new ASTMethodNode(JJTMETHODNODE);
5819 boolean jjtc001 = true;
5820 jjtree.openNodeScope(jjtn001);
5821 jjtreeOpenNodeScope(jjtn001);
5822 jjtn001.jjtSetFirstToken(getToken(1));
5823 try {
5824 MemberAccess();
5825 label_37:
5826 while (true) {
5827 Arguments();
5828 if (jj_2_103(2147483647)) {
5829 } else {
5830 break label_37;
5831 }
5832 }
5833 } catch (Throwable jjte001) {
5834 if (jjtc001) {
5835 jjtree.clearNodeScope(jjtn001);
5836 jjtc001 = false;
5837 } else {
5838 jjtree.popNode();
5839 }
5840 if (jjte001 instanceof ParseException) {
5841 throw (ParseException)jjte001;
5842 }
5843 if (jjte001 instanceof RuntimeException) {
5844 throw (RuntimeException)jjte001;
5845 }
5846 throw (Error)jjte001;
5847 } finally {
5848 if (jjtc001) {
5849 jjtree.closeNodeScope(jjtn001, jjtree.nodeArity() > 1);
5850 if (jjtree.nodeCreated()) {
5851 jjtreeCloseNodeScope(jjtn001);
5852 }
5853 jjtn001.jjtSetLastToken(getToken(0));
5854 }
5855 }
5856 }
5857
5858 final public void MethodCallLookahead() throws ParseException {
5859 MemberAccess();
5860 jj_consume_token(LPAREN);
5861 }
5862
5863 final public void MemberExpression() throws ParseException {
5864 if (jj_2_104(2147483647)) {
5865 MethodCall();
5866 } else {
5867 switch (jj_nt.kind) {
5868 case LBRACKET:
5869 case QLBRACKET:
5870 case DOT:
5871 case QDOT:{
5872 MemberAccess();
5873 break;
5874 }
5875 default:
5876 jj_consume_token(-1);
5877 throw new ParseException();
5878 }
5879 }
5880 }
5881
5882 final public void ValueExpression() throws ParseException {
5883 ASTReference jjtn001 = new ASTReference(JJTREFERENCE);
5884 boolean jjtc001 = true;
5885 jjtree.openNodeScope(jjtn001);
5886 jjtreeOpenNodeScope(jjtn001);
5887 jjtn001.jjtSetFirstToken(getToken(1));
5888 try {
5889 PrimaryExpression();
5890 label_38:
5891 while (true) {
5892 if (jj_2_105(2)) {
5893 } else {
5894 break label_38;
5895 }
5896 MemberExpression();
5897 }
5898 } catch (Throwable jjte001) {
5899 if (jjtc001) {
5900 jjtree.clearNodeScope(jjtn001);
5901 jjtc001 = false;
5902 } else {
5903 jjtree.popNode();
5904 }
5905 if (jjte001 instanceof ParseException) {
5906 throw (ParseException)jjte001;
5907 }
5908 if (jjte001 instanceof RuntimeException) {
5909 throw (RuntimeException)jjte001;
5910 }
5911 throw (Error)jjte001;
5912 } finally {
5913 if (jjtc001) {
5914 jjtree.closeNodeScope(jjtn001, jjtree.nodeArity() > 1);
5915 if (jjtree.nodeCreated()) {
5916 jjtreeCloseNodeScope(jjtn001);
5917 }
5918 jjtn001.jjtSetLastToken(getToken(0));
5919 }
5920 }
5921 }
5922
5923 private boolean jj_2_1(int xla)
5924 {
5925 jj_la = xla;
5926 jj_scanpos = token;
5927 jj_lastpos = token;
5928 try { return (!jj_3_1()); }
5929 catch(LookaheadSuccess ls) { return true; }
5930 }
5931
5932 private boolean jj_2_2(int xla)
5933 {
5934 jj_la = xla;
5935 jj_scanpos = token;
5936 jj_lastpos = token;
5937 try { return (!jj_3_2()); }
5938 catch(LookaheadSuccess ls) { return true; }
5939 }
5940
5941 private boolean jj_2_3(int xla)
5942 {
5943 jj_la = xla;
5944 jj_scanpos = token;
5945 jj_lastpos = token;
5946 try { return (!jj_3_3()); }
5947 catch(LookaheadSuccess ls) { return true; }
5948 }
5949
5950 private boolean jj_2_4(int xla)
5951 {
5952 jj_la = xla;
5953 jj_scanpos = token;
5954 jj_lastpos = token;
5955 try { return (!jj_3_4()); }
5956 catch(LookaheadSuccess ls) { return true; }
5957 }
5958
5959 private boolean jj_2_5(int xla)
5960 {
5961 jj_la = xla;
5962 jj_scanpos = token;
5963 jj_lastpos = token;
5964 try { return (!jj_3_5()); }
5965 catch(LookaheadSuccess ls) { return true; }
5966 }
5967
5968 private boolean jj_2_6(int xla)
5969 {
5970 jj_la = xla;
5971 jj_scanpos = token;
5972 jj_lastpos = token;
5973 try { return (!jj_3_6()); }
5974 catch(LookaheadSuccess ls) { return true; }
5975 }
5976
5977 private boolean jj_2_7(int xla)
5978 {
5979 jj_la = xla;
5980 jj_scanpos = token;
5981 jj_lastpos = token;
5982 try { return (!jj_3_7()); }
5983 catch(LookaheadSuccess ls) { return true; }
5984 }
5985
5986 private boolean jj_2_8(int xla)
5987 {
5988 jj_la = xla;
5989 jj_scanpos = token;
5990 jj_lastpos = token;
5991 try { return (!jj_3_8()); }
5992 catch(LookaheadSuccess ls) { return true; }
5993 }
5994
5995 private boolean jj_2_9(int xla)
5996 {
5997 jj_la = xla;
5998 jj_scanpos = token;
5999 jj_lastpos = token;
6000 try { return (!jj_3_9()); }
6001 catch(LookaheadSuccess ls) { return true; }
6002 }
6003
6004 private boolean jj_2_10(int xla)
6005 {
6006 jj_la = xla;
6007 jj_scanpos = token;
6008 jj_lastpos = token;
6009 try { return (!jj_3_10()); }
6010 catch(LookaheadSuccess ls) { return true; }
6011 }
6012
6013 private boolean jj_2_11(int xla)
6014 {
6015 jj_la = xla;
6016 jj_scanpos = token;
6017 jj_lastpos = token;
6018 try { return (!jj_3_11()); }
6019 catch(LookaheadSuccess ls) { return true; }
6020 }
6021
6022 private boolean jj_2_12(int xla)
6023 {
6024 jj_la = xla;
6025 jj_scanpos = token;
6026 jj_lastpos = token;
6027 try { return (!jj_3_12()); }
6028 catch(LookaheadSuccess ls) { return true; }
6029 }
6030
6031 private boolean jj_2_13(int xla)
6032 {
6033 jj_la = xla;
6034 jj_scanpos = token;
6035 jj_lastpos = token;
6036 try { return (!jj_3_13()); }
6037 catch(LookaheadSuccess ls) { return true; }
6038 }
6039
6040 private boolean jj_2_14(int xla)
6041 {
6042 jj_la = xla;
6043 jj_scanpos = token;
6044 jj_lastpos = token;
6045 try { return (!jj_3_14()); }
6046 catch(LookaheadSuccess ls) { return true; }
6047 }
6048
6049 private boolean jj_2_15(int xla)
6050 {
6051 jj_la = xla;
6052 jj_scanpos = token;
6053 jj_lastpos = token;
6054 try { return (!jj_3_15()); }
6055 catch(LookaheadSuccess ls) { return true; }
6056 }
6057
6058 private boolean jj_2_16(int xla)
6059 {
6060 jj_la = xla;
6061 jj_scanpos = token;
6062 jj_lastpos = token;
6063 try { return (!jj_3_16()); }
6064 catch(LookaheadSuccess ls) { return true; }
6065 }
6066
6067 private boolean jj_2_17(int xla)
6068 {
6069 jj_la = xla;
6070 jj_scanpos = token;
6071 jj_lastpos = token;
6072 try { return (!jj_3_17()); }
6073 catch(LookaheadSuccess ls) { return true; }
6074 }
6075
6076 private boolean jj_2_18(int xla)
6077 {
6078 jj_la = xla;
6079 jj_scanpos = token;
6080 jj_lastpos = token;
6081 try { return (!jj_3_18()); }
6082 catch(LookaheadSuccess ls) { return true; }
6083 }
6084
6085 private boolean jj_2_19(int xla)
6086 {
6087 jj_la = xla;
6088 jj_scanpos = token;
6089 jj_lastpos = token;
6090 try { return (!jj_3_19()); }
6091 catch(LookaheadSuccess ls) { return true; }
6092 }
6093
6094 private boolean jj_2_20(int xla)
6095 {
6096 jj_la = xla;
6097 jj_scanpos = token;
6098 jj_lastpos = token;
6099 try { return (!jj_3_20()); }
6100 catch(LookaheadSuccess ls) { return true; }
6101 }
6102
6103 private boolean jj_2_21(int xla)
6104 {
6105 jj_la = xla;
6106 jj_scanpos = token;
6107 jj_lastpos = token;
6108 try { return (!jj_3_21()); }
6109 catch(LookaheadSuccess ls) { return true; }
6110 }
6111
6112 private boolean jj_2_22(int xla)
6113 {
6114 jj_la = xla;
6115 jj_scanpos = token;
6116 jj_lastpos = token;
6117 try { return (!jj_3_22()); }
6118 catch(LookaheadSuccess ls) { return true; }
6119 }
6120
6121 private boolean jj_2_23(int xla)
6122 {
6123 jj_la = xla;
6124 jj_scanpos = token;
6125 jj_lastpos = token;
6126 try { return (!jj_3_23()); }
6127 catch(LookaheadSuccess ls) { return true; }
6128 }
6129
6130 private boolean jj_2_24(int xla)
6131 {
6132 jj_la = xla;
6133 jj_scanpos = token;
6134 jj_lastpos = token;
6135 try { return (!jj_3_24()); }
6136 catch(LookaheadSuccess ls) { return true; }
6137 }
6138
6139 private boolean jj_2_25(int xla)
6140 {
6141 jj_la = xla;
6142 jj_scanpos = token;
6143 jj_lastpos = token;
6144 try { return (!jj_3_25()); }
6145 catch(LookaheadSuccess ls) { return true; }
6146 }
6147
6148 private boolean jj_2_26(int xla)
6149 {
6150 jj_la = xla;
6151 jj_scanpos = token;
6152 jj_lastpos = token;
6153 try { return (!jj_3_26()); }
6154 catch(LookaheadSuccess ls) { return true; }
6155 }
6156
6157 private boolean jj_2_27(int xla)
6158 {
6159 jj_la = xla;
6160 jj_scanpos = token;
6161 jj_lastpos = token;
6162 try { return (!jj_3_27()); }
6163 catch(LookaheadSuccess ls) { return true; }
6164 }
6165
6166 private boolean jj_2_28(int xla)
6167 {
6168 jj_la = xla;
6169 jj_scanpos = token;
6170 jj_lastpos = token;
6171 try { return (!jj_3_28()); }
6172 catch(LookaheadSuccess ls) { return true; }
6173 }
6174
6175 private boolean jj_2_29(int xla)
6176 {
6177 jj_la = xla;
6178 jj_scanpos = token;
6179 jj_lastpos = token;
6180 try { return (!jj_3_29()); }
6181 catch(LookaheadSuccess ls) { return true; }
6182 }
6183
6184 private boolean jj_2_30(int xla)
6185 {
6186 jj_la = xla;
6187 jj_scanpos = token;
6188 jj_lastpos = token;
6189 try { return (!jj_3_30()); }
6190 catch(LookaheadSuccess ls) { return true; }
6191 }
6192
6193 private boolean jj_2_31(int xla)
6194 {
6195 jj_la = xla;
6196 jj_scanpos = token;
6197 jj_lastpos = token;
6198 try { return (!jj_3_31()); }
6199 catch(LookaheadSuccess ls) { return true; }
6200 }
6201
6202 private boolean jj_2_32(int xla)
6203 {
6204 jj_la = xla;
6205 jj_scanpos = token;
6206 jj_lastpos = token;
6207 try { return (!jj_3_32()); }
6208 catch(LookaheadSuccess ls) { return true; }
6209 }
6210
6211 private boolean jj_2_33(int xla)
6212 {
6213 jj_la = xla;
6214 jj_scanpos = token;
6215 jj_lastpos = token;
6216 try { return (!jj_3_33()); }
6217 catch(LookaheadSuccess ls) { return true; }
6218 }
6219
6220 private boolean jj_2_34(int xla)
6221 {
6222 jj_la = xla;
6223 jj_scanpos = token;
6224 jj_lastpos = token;
6225 try { return (!jj_3_34()); }
6226 catch(LookaheadSuccess ls) { return true; }
6227 }
6228
6229 private boolean jj_2_35(int xla)
6230 {
6231 jj_la = xla;
6232 jj_scanpos = token;
6233 jj_lastpos = token;
6234 try { return (!jj_3_35()); }
6235 catch(LookaheadSuccess ls) { return true; }
6236 }
6237
6238 private boolean jj_2_36(int xla)
6239 {
6240 jj_la = xla;
6241 jj_scanpos = token;
6242 jj_lastpos = token;
6243 try { return (!jj_3_36()); }
6244 catch(LookaheadSuccess ls) { return true; }
6245 }
6246
6247 private boolean jj_2_37(int xla)
6248 {
6249 jj_la = xla;
6250 jj_scanpos = token;
6251 jj_lastpos = token;
6252 try { return (!jj_3_37()); }
6253 catch(LookaheadSuccess ls) { return true; }
6254 }
6255
6256 private boolean jj_2_38(int xla)
6257 {
6258 jj_la = xla;
6259 jj_scanpos = token;
6260 jj_lastpos = token;
6261 try { return (!jj_3_38()); }
6262 catch(LookaheadSuccess ls) { return true; }
6263 }
6264
6265 private boolean jj_2_39(int xla)
6266 {
6267 jj_la = xla;
6268 jj_scanpos = token;
6269 jj_lastpos = token;
6270 try { return (!jj_3_39()); }
6271 catch(LookaheadSuccess ls) { return true; }
6272 }
6273
6274 private boolean jj_2_40(int xla)
6275 {
6276 jj_la = xla;
6277 jj_scanpos = token;
6278 jj_lastpos = token;
6279 try { return (!jj_3_40()); }
6280 catch(LookaheadSuccess ls) { return true; }
6281 }
6282
6283 private boolean jj_2_41(int xla)
6284 {
6285 jj_la = xla;
6286 jj_scanpos = token;
6287 jj_lastpos = token;
6288 try { return (!jj_3_41()); }
6289 catch(LookaheadSuccess ls) { return true; }
6290 }
6291
6292 private boolean jj_2_42(int xla)
6293 {
6294 jj_la = xla;
6295 jj_scanpos = token;
6296 jj_lastpos = token;
6297 try { return (!jj_3_42()); }
6298 catch(LookaheadSuccess ls) { return true; }
6299 }
6300
6301 private boolean jj_2_43(int xla)
6302 {
6303 jj_la = xla;
6304 jj_scanpos = token;
6305 jj_lastpos = token;
6306 try { return (!jj_3_43()); }
6307 catch(LookaheadSuccess ls) { return true; }
6308 }
6309
6310 private boolean jj_2_44(int xla)
6311 {
6312 jj_la = xla;
6313 jj_scanpos = token;
6314 jj_lastpos = token;
6315 try { return (!jj_3_44()); }
6316 catch(LookaheadSuccess ls) { return true; }
6317 }
6318
6319 private boolean jj_2_45(int xla)
6320 {
6321 jj_la = xla;
6322 jj_scanpos = token;
6323 jj_lastpos = token;
6324 try { return (!jj_3_45()); }
6325 catch(LookaheadSuccess ls) { return true; }
6326 }
6327
6328 private boolean jj_2_46(int xla)
6329 {
6330 jj_la = xla;
6331 jj_scanpos = token;
6332 jj_lastpos = token;
6333 try { return (!jj_3_46()); }
6334 catch(LookaheadSuccess ls) { return true; }
6335 }
6336
6337 private boolean jj_2_47(int xla)
6338 {
6339 jj_la = xla;
6340 jj_scanpos = token;
6341 jj_lastpos = token;
6342 try { return (!jj_3_47()); }
6343 catch(LookaheadSuccess ls) { return true; }
6344 }
6345
6346 private boolean jj_2_48(int xla)
6347 {
6348 jj_la = xla;
6349 jj_scanpos = token;
6350 jj_lastpos = token;
6351 try { return (!jj_3_48()); }
6352 catch(LookaheadSuccess ls) { return true; }
6353 }
6354
6355 private boolean jj_2_49(int xla)
6356 {
6357 jj_la = xla;
6358 jj_scanpos = token;
6359 jj_lastpos = token;
6360 try { return (!jj_3_49()); }
6361 catch(LookaheadSuccess ls) { return true; }
6362 }
6363
6364 private boolean jj_2_50(int xla)
6365 {
6366 jj_la = xla;
6367 jj_scanpos = token;
6368 jj_lastpos = token;
6369 try { return (!jj_3_50()); }
6370 catch(LookaheadSuccess ls) { return true; }
6371 }
6372
6373 private boolean jj_2_51(int xla)
6374 {
6375 jj_la = xla;
6376 jj_scanpos = token;
6377 jj_lastpos = token;
6378 try { return (!jj_3_51()); }
6379 catch(LookaheadSuccess ls) { return true; }
6380 }
6381
6382 private boolean jj_2_52(int xla)
6383 {
6384 jj_la = xla;
6385 jj_scanpos = token;
6386 jj_lastpos = token;
6387 try { return (!jj_3_52()); }
6388 catch(LookaheadSuccess ls) { return true; }
6389 }
6390
6391 private boolean jj_2_53(int xla)
6392 {
6393 jj_la = xla;
6394 jj_scanpos = token;
6395 jj_lastpos = token;
6396 try { return (!jj_3_53()); }
6397 catch(LookaheadSuccess ls) { return true; }
6398 }
6399
6400 private boolean jj_2_54(int xla)
6401 {
6402 jj_la = xla;
6403 jj_scanpos = token;
6404 jj_lastpos = token;
6405 try { return (!jj_3_54()); }
6406 catch(LookaheadSuccess ls) { return true; }
6407 }
6408
6409 private boolean jj_2_55(int xla)
6410 {
6411 jj_la = xla;
6412 jj_scanpos = token;
6413 jj_lastpos = token;
6414 try { return (!jj_3_55()); }
6415 catch(LookaheadSuccess ls) { return true; }
6416 }
6417
6418 private boolean jj_2_56(int xla)
6419 {
6420 jj_la = xla;
6421 jj_scanpos = token;
6422 jj_lastpos = token;
6423 try { return (!jj_3_56()); }
6424 catch(LookaheadSuccess ls) { return true; }
6425 }
6426
6427 private boolean jj_2_57(int xla)
6428 {
6429 jj_la = xla;
6430 jj_scanpos = token;
6431 jj_lastpos = token;
6432 try { return (!jj_3_57()); }
6433 catch(LookaheadSuccess ls) { return true; }
6434 }
6435
6436 private boolean jj_2_58(int xla)
6437 {
6438 jj_la = xla;
6439 jj_scanpos = token;
6440 jj_lastpos = token;
6441 try { return (!jj_3_58()); }
6442 catch(LookaheadSuccess ls) { return true; }
6443 }
6444
6445 private boolean jj_2_59(int xla)
6446 {
6447 jj_la = xla;
6448 jj_scanpos = token;
6449 jj_lastpos = token;
6450 try { return (!jj_3_59()); }
6451 catch(LookaheadSuccess ls) { return true; }
6452 }
6453
6454 private boolean jj_2_60(int xla)
6455 {
6456 jj_la = xla;
6457 jj_scanpos = token;
6458 jj_lastpos = token;
6459 try { return (!jj_3_60()); }
6460 catch(LookaheadSuccess ls) { return true; }
6461 }
6462
6463 private boolean jj_2_61(int xla)
6464 {
6465 jj_la = xla;
6466 jj_scanpos = token;
6467 jj_lastpos = token;
6468 try { return (!jj_3_61()); }
6469 catch(LookaheadSuccess ls) { return true; }
6470 }
6471
6472 private boolean jj_2_62(int xla)
6473 {
6474 jj_la = xla;
6475 jj_scanpos = token;
6476 jj_lastpos = token;
6477 try { return (!jj_3_62()); }
6478 catch(LookaheadSuccess ls) { return true; }
6479 }
6480
6481 private boolean jj_2_63(int xla)
6482 {
6483 jj_la = xla;
6484 jj_scanpos = token;
6485 jj_lastpos = token;
6486 try { return (!jj_3_63()); }
6487 catch(LookaheadSuccess ls) { return true; }
6488 }
6489
6490 private boolean jj_2_64(int xla)
6491 {
6492 jj_la = xla;
6493 jj_scanpos = token;
6494 jj_lastpos = token;
6495 try { return (!jj_3_64()); }
6496 catch(LookaheadSuccess ls) { return true; }
6497 }
6498
6499 private boolean jj_2_65(int xla)
6500 {
6501 jj_la = xla;
6502 jj_scanpos = token;
6503 jj_lastpos = token;
6504 try { return (!jj_3_65()); }
6505 catch(LookaheadSuccess ls) { return true; }
6506 }
6507
6508 private boolean jj_2_66(int xla)
6509 {
6510 jj_la = xla;
6511 jj_scanpos = token;
6512 jj_lastpos = token;
6513 try { return (!jj_3_66()); }
6514 catch(LookaheadSuccess ls) { return true; }
6515 }
6516
6517 private boolean jj_2_67(int xla)
6518 {
6519 jj_la = xla;
6520 jj_scanpos = token;
6521 jj_lastpos = token;
6522 try { return (!jj_3_67()); }
6523 catch(LookaheadSuccess ls) { return true; }
6524 }
6525
6526 private boolean jj_2_68(int xla)
6527 {
6528 jj_la = xla;
6529 jj_scanpos = token;
6530 jj_lastpos = token;
6531 try { return (!jj_3_68()); }
6532 catch(LookaheadSuccess ls) { return true; }
6533 }
6534
6535 private boolean jj_2_69(int xla)
6536 {
6537 jj_la = xla;
6538 jj_scanpos = token;
6539 jj_lastpos = token;
6540 try { return (!jj_3_69()); }
6541 catch(LookaheadSuccess ls) { return true; }
6542 }
6543
6544 private boolean jj_2_70(int xla)
6545 {
6546 jj_la = xla;
6547 jj_scanpos = token;
6548 jj_lastpos = token;
6549 try { return (!jj_3_70()); }
6550 catch(LookaheadSuccess ls) { return true; }
6551 }
6552
6553 private boolean jj_2_71(int xla)
6554 {
6555 jj_la = xla;
6556 jj_scanpos = token;
6557 jj_lastpos = token;
6558 try { return (!jj_3_71()); }
6559 catch(LookaheadSuccess ls) { return true; }
6560 }
6561
6562 private boolean jj_2_72(int xla)
6563 {
6564 jj_la = xla;
6565 jj_scanpos = token;
6566 jj_lastpos = token;
6567 try { return (!jj_3_72()); }
6568 catch(LookaheadSuccess ls) { return true; }
6569 }
6570
6571 private boolean jj_2_73(int xla)
6572 {
6573 jj_la = xla;
6574 jj_scanpos = token;
6575 jj_lastpos = token;
6576 try { return (!jj_3_73()); }
6577 catch(LookaheadSuccess ls) { return true; }
6578 }
6579
6580 private boolean jj_2_74(int xla)
6581 {
6582 jj_la = xla;
6583 jj_scanpos = token;
6584 jj_lastpos = token;
6585 try { return (!jj_3_74()); }
6586 catch(LookaheadSuccess ls) { return true; }
6587 }
6588
6589 private boolean jj_2_75(int xla)
6590 {
6591 jj_la = xla;
6592 jj_scanpos = token;
6593 jj_lastpos = token;
6594 try { return (!jj_3_75()); }
6595 catch(LookaheadSuccess ls) { return true; }
6596 }
6597
6598 private boolean jj_2_76(int xla)
6599 {
6600 jj_la = xla;
6601 jj_scanpos = token;
6602 jj_lastpos = token;
6603 try { return (!jj_3_76()); }
6604 catch(LookaheadSuccess ls) { return true; }
6605 }
6606
6607 private boolean jj_2_77(int xla)
6608 {
6609 jj_la = xla;
6610 jj_scanpos = token;
6611 jj_lastpos = token;
6612 try { return (!jj_3_77()); }
6613 catch(LookaheadSuccess ls) { return true; }
6614 }
6615
6616 private boolean jj_2_78(int xla)
6617 {
6618 jj_la = xla;
6619 jj_scanpos = token;
6620 jj_lastpos = token;
6621 try { return (!jj_3_78()); }
6622 catch(LookaheadSuccess ls) { return true; }
6623 }
6624
6625 private boolean jj_2_79(int xla)
6626 {
6627 jj_la = xla;
6628 jj_scanpos = token;
6629 jj_lastpos = token;
6630 try { return (!jj_3_79()); }
6631 catch(LookaheadSuccess ls) { return true; }
6632 }
6633
6634 private boolean jj_2_80(int xla)
6635 {
6636 jj_la = xla;
6637 jj_scanpos = token;
6638 jj_lastpos = token;
6639 try { return (!jj_3_80()); }
6640 catch(LookaheadSuccess ls) { return true; }
6641 }
6642
6643 private boolean jj_2_81(int xla)
6644 {
6645 jj_la = xla;
6646 jj_scanpos = token;
6647 jj_lastpos = token;
6648 try { return (!jj_3_81()); }
6649 catch(LookaheadSuccess ls) { return true; }
6650 }
6651
6652 private boolean jj_2_82(int xla)
6653 {
6654 jj_la = xla;
6655 jj_scanpos = token;
6656 jj_lastpos = token;
6657 try { return (!jj_3_82()); }
6658 catch(LookaheadSuccess ls) { return true; }
6659 }
6660
6661 private boolean jj_2_83(int xla)
6662 {
6663 jj_la = xla;
6664 jj_scanpos = token;
6665 jj_lastpos = token;
6666 try { return (!jj_3_83()); }
6667 catch(LookaheadSuccess ls) { return true; }
6668 }
6669
6670 private boolean jj_2_84(int xla)
6671 {
6672 jj_la = xla;
6673 jj_scanpos = token;
6674 jj_lastpos = token;
6675 try { return (!jj_3_84()); }
6676 catch(LookaheadSuccess ls) { return true; }
6677 }
6678
6679 private boolean jj_2_85(int xla)
6680 {
6681 jj_la = xla;
6682 jj_scanpos = token;
6683 jj_lastpos = token;
6684 try { return (!jj_3_85()); }
6685 catch(LookaheadSuccess ls) { return true; }
6686 }
6687
6688 private boolean jj_2_86(int xla)
6689 {
6690 jj_la = xla;
6691 jj_scanpos = token;
6692 jj_lastpos = token;
6693 try { return (!jj_3_86()); }
6694 catch(LookaheadSuccess ls) { return true; }
6695 }
6696
6697 private boolean jj_2_87(int xla)
6698 {
6699 jj_la = xla;
6700 jj_scanpos = token;
6701 jj_lastpos = token;
6702 try { return (!jj_3_87()); }
6703 catch(LookaheadSuccess ls) { return true; }
6704 }
6705
6706 private boolean jj_2_88(int xla)
6707 {
6708 jj_la = xla;
6709 jj_scanpos = token;
6710 jj_lastpos = token;
6711 try { return (!jj_3_88()); }
6712 catch(LookaheadSuccess ls) { return true; }
6713 }
6714
6715 private boolean jj_2_89(int xla)
6716 {
6717 jj_la = xla;
6718 jj_scanpos = token;
6719 jj_lastpos = token;
6720 try { return (!jj_3_89()); }
6721 catch(LookaheadSuccess ls) { return true; }
6722 }
6723
6724 private boolean jj_2_90(int xla)
6725 {
6726 jj_la = xla;
6727 jj_scanpos = token;
6728 jj_lastpos = token;
6729 try { return (!jj_3_90()); }
6730 catch(LookaheadSuccess ls) { return true; }
6731 }
6732
6733 private boolean jj_2_91(int xla)
6734 {
6735 jj_la = xla;
6736 jj_scanpos = token;
6737 jj_lastpos = token;
6738 try { return (!jj_3_91()); }
6739 catch(LookaheadSuccess ls) { return true; }
6740 }
6741
6742 private boolean jj_2_92(int xla)
6743 {
6744 jj_la = xla;
6745 jj_scanpos = token;
6746 jj_lastpos = token;
6747 try { return (!jj_3_92()); }
6748 catch(LookaheadSuccess ls) { return true; }
6749 }
6750
6751 private boolean jj_2_93(int xla)
6752 {
6753 jj_la = xla;
6754 jj_scanpos = token;
6755 jj_lastpos = token;
6756 try { return (!jj_3_93()); }
6757 catch(LookaheadSuccess ls) { return true; }
6758 }
6759
6760 private boolean jj_2_94(int xla)
6761 {
6762 jj_la = xla;
6763 jj_scanpos = token;
6764 jj_lastpos = token;
6765 try { return (!jj_3_94()); }
6766 catch(LookaheadSuccess ls) { return true; }
6767 }
6768
6769 private boolean jj_2_95(int xla)
6770 {
6771 jj_la = xla;
6772 jj_scanpos = token;
6773 jj_lastpos = token;
6774 try { return (!jj_3_95()); }
6775 catch(LookaheadSuccess ls) { return true; }
6776 }
6777
6778 private boolean jj_2_96(int xla)
6779 {
6780 jj_la = xla;
6781 jj_scanpos = token;
6782 jj_lastpos = token;
6783 try { return (!jj_3_96()); }
6784 catch(LookaheadSuccess ls) { return true; }
6785 }
6786
6787 private boolean jj_2_97(int xla)
6788 {
6789 jj_la = xla;
6790 jj_scanpos = token;
6791 jj_lastpos = token;
6792 try { return (!jj_3_97()); }
6793 catch(LookaheadSuccess ls) { return true; }
6794 }
6795
6796 private boolean jj_2_98(int xla)
6797 {
6798 jj_la = xla;
6799 jj_scanpos = token;
6800 jj_lastpos = token;
6801 try { return (!jj_3_98()); }
6802 catch(LookaheadSuccess ls) { return true; }
6803 }
6804
6805 private boolean jj_2_99(int xla)
6806 {
6807 jj_la = xla;
6808 jj_scanpos = token;
6809 jj_lastpos = token;
6810 try { return (!jj_3_99()); }
6811 catch(LookaheadSuccess ls) { return true; }
6812 }
6813
6814 private boolean jj_2_100(int xla)
6815 {
6816 jj_la = xla;
6817 jj_scanpos = token;
6818 jj_lastpos = token;
6819 try { return (!jj_3_100()); }
6820 catch(LookaheadSuccess ls) { return true; }
6821 }
6822
6823 private boolean jj_2_101(int xla)
6824 {
6825 jj_la = xla;
6826 jj_scanpos = token;
6827 jj_lastpos = token;
6828 try { return (!jj_3_101()); }
6829 catch(LookaheadSuccess ls) { return true; }
6830 }
6831
6832 private boolean jj_2_102(int xla)
6833 {
6834 jj_la = xla;
6835 jj_scanpos = token;
6836 jj_lastpos = token;
6837 try { return (!jj_3_102()); }
6838 catch(LookaheadSuccess ls) { return true; }
6839 }
6840
6841 private boolean jj_2_103(int xla)
6842 {
6843 jj_la = xla;
6844 jj_scanpos = token;
6845 jj_lastpos = token;
6846 try { return (!jj_3_103()); }
6847 catch(LookaheadSuccess ls) { return true; }
6848 }
6849
6850 private boolean jj_2_104(int xla)
6851 {
6852 jj_la = xla;
6853 jj_scanpos = token;
6854 jj_lastpos = token;
6855 try { return (!jj_3_104()); }
6856 catch(LookaheadSuccess ls) { return true; }
6857 }
6858
6859 private boolean jj_2_105(int xla)
6860 {
6861 jj_la = xla;
6862 jj_scanpos = token;
6863 jj_lastpos = token;
6864 try { return (!jj_3_105()); }
6865 catch(LookaheadSuccess ls) { return true; }
6866 }
6867
6868 private boolean jj_3R_263()
6869 {
6870 if (jj_scan_token(NULL)) return true;
6871 return false;
6872 }
6873
6874 private boolean jj_3R_259()
6875 {
6876 Token xsp;
6877 xsp = jj_scanpos;
6878 if (jj_3R_265()) {
6879 jj_scanpos = xsp;
6880 if (jj_3R_266()) return true;
6881 }
6882 return false;
6883 }
6884
6885 private boolean jj_3R_265()
6886 {
6887 if (jj_scan_token(TRUE)) return true;
6888 return false;
6889 }
6890
6891 private boolean jj_3R_266()
6892 {
6893 if (jj_scan_token(FALSE)) return true;
6894 return false;
6895 }
6896
6897 private boolean jj_3R_257()
6898 {
6899 if (jj_scan_token(INTEGER_LITERAL)) return true;
6900 return false;
6901 }
6902
6903 private boolean jj_3R_258()
6904 {
6905 if (jj_scan_token(FLOAT_LITERAL)) return true;
6906 return false;
6907 }
6908
6909 private boolean jj_3R_261()
6910 {
6911 if (jj_scan_token(STRING_LITERAL)) return true;
6912 return false;
6913 }
6914
6915 private boolean jj_3R_260()
6916 {
6917 if (jj_scan_token(JXLT_LITERAL)) return true;
6918 return false;
6919 }
6920
6921 private boolean jj_3R_262()
6922 {
6923 if (jj_scan_token(REGEX_LITERAL)) return true;
6924 return false;
6925 }
6926
6927 private boolean jj_3R_284()
6928 {
6929 if (jj_scan_token(ELIPSIS)) return true;
6930 return false;
6931 }
6932
6933 private boolean jj_3R_227()
6934 {
6935 if (jj_scan_token(LBRACKET)) return true;
6936 Token xsp;
6937 xsp = jj_scanpos;
6938 if (jj_3R_279()) {
6939 jj_scanpos = xsp;
6940 if (jj_3R_280()) return true;
6941 }
6942 if (jj_scan_token(RBRACKET)) return true;
6943 return false;
6944 }
6945
6946 private boolean jj_3R_279()
6947 {
6948 Token xsp;
6949 xsp = jj_scanpos;
6950 if (jj_scan_token(23)) jj_scanpos = xsp;
6951 if (jj_3R_284()) return true;
6952 return false;
6953 }
6954
6955 private boolean jj_3R_280()
6956 {
6957 Token xsp;
6958 xsp = jj_scanpos;
6959 if (jj_3_66()) jj_scanpos = xsp;
6960 return false;
6961 }
6962
6963 private boolean jj_3_66()
6964 {
6965 if (jj_3R_41()) return true;
6966 Token xsp;
6967 while (true) {
6968 xsp = jj_scanpos;
6969 if (jj_3_65()) { jj_scanpos = xsp; break; }
6970 }
6971 xsp = jj_scanpos;
6972 if (jj_3R_291()) jj_scanpos = xsp;
6973 return false;
6974 }
6975
6976 private boolean jj_3R_225()
6977 {
6978 if (jj_scan_token(LCURLY)) return true;
6979 Token xsp;
6980 xsp = jj_scanpos;
6981 if (jj_3_68()) {
6982 jj_scanpos = xsp;
6983 if (jj_scan_token(22)) return true;
6984 }
6985 if (jj_scan_token(RCURLY)) return true;
6986 return false;
6987 }
6988
6989 private boolean jj_3R_291()
6990 {
6991 if (jj_scan_token(COMMA)) return true;
6992 Token xsp;
6993 xsp = jj_scanpos;
6994 if (jj_3R_296()) jj_scanpos = xsp;
6995 return false;
6996 }
6997
6998 private boolean jj_3_68()
6999 {
7000 if (jj_3R_110()) return true;
7001 Token xsp;
7002 while (true) {
7003 xsp = jj_scanpos;
7004 if (jj_3_67()) { jj_scanpos = xsp; break; }
7005 }
7006 xsp = jj_scanpos;
7007 if (jj_3R_282()) jj_scanpos = xsp;
7008 return false;
7009 }
7010
7011 private boolean jj_3_65()
7012 {
7013 if (jj_scan_token(COMMA)) return true;
7014 if (jj_3R_41()) return true;
7015 return false;
7016 }
7017
7018 private boolean jj_3_69()
7019 {
7020 if (jj_3R_111()) return true;
7021 if (jj_scan_token(COLON)) return true;
7022 if (jj_3R_41()) return true;
7023 return false;
7024 }
7025
7026 private boolean jj_3R_110()
7027 {
7028 Token xsp;
7029 xsp = jj_scanpos;
7030 if (jj_3_69()) {
7031 jj_scanpos = xsp;
7032 if (jj_3_70()) return true;
7033 }
7034 return false;
7035 }
7036
7037 private boolean jj_3R_296()
7038 {
7039 if (jj_3R_284()) return true;
7040 return false;
7041 }
7042
7043 private boolean jj_3R_282()
7044 {
7045 if (jj_scan_token(COMMA)) return true;
7046 Token xsp;
7047 xsp = jj_scanpos;
7048 if (jj_3R_289()) jj_scanpos = xsp;
7049 return false;
7050 }
7051
7052 private boolean jj_3_70()
7053 {
7054 if (jj_3R_41()) return true;
7055 if (jj_scan_token(COLON)) return true;
7056 if (jj_3R_41()) return true;
7057 return false;
7058 }
7059
7060 private boolean jj_3_67()
7061 {
7062 if (jj_scan_token(COMMA)) return true;
7063 if (jj_3R_110()) return true;
7064 return false;
7065 }
7066
7067 private boolean jj_3R_226()
7068 {
7069 if (jj_scan_token(LCURLY)) return true;
7070 Token xsp;
7071 xsp = jj_scanpos;
7072 if (jj_3_72()) jj_scanpos = xsp;
7073 if (jj_scan_token(RCURLY)) return true;
7074 return false;
7075 }
7076
7077 private boolean jj_3_72()
7078 {
7079 if (jj_3R_41()) return true;
7080 Token xsp;
7081 while (true) {
7082 xsp = jj_scanpos;
7083 if (jj_3_71()) { jj_scanpos = xsp; break; }
7084 }
7085 xsp = jj_scanpos;
7086 if (jj_3R_283()) jj_scanpos = xsp;
7087 return false;
7088 }
7089
7090 private boolean jj_3R_289()
7091 {
7092 if (jj_3R_284()) return true;
7093 return false;
7094 }
7095
7096 private boolean jj_3R_283()
7097 {
7098 if (jj_scan_token(COMMA)) return true;
7099 Token xsp;
7100 xsp = jj_scanpos;
7101 if (jj_3R_290()) jj_scanpos = xsp;
7102 return false;
7103 }
7104
7105 private boolean jj_3R_42()
7106 {
7107 if (jj_scan_token(LPAREN)) return true;
7108 Token xsp;
7109 xsp = jj_scanpos;
7110 if (jj_3_73()) jj_scanpos = xsp;
7111 if (jj_scan_token(RPAREN)) return true;
7112 return false;
7113 }
7114
7115 private boolean jj_3_71()
7116 {
7117 if (jj_scan_token(COMMA)) return true;
7118 if (jj_3R_41()) return true;
7119 return false;
7120 }
7121
7122 private boolean jj_3R_290()
7123 {
7124 if (jj_3R_284()) return true;
7125 return false;
7126 }
7127
7128 private boolean jj_3R_113()
7129 {
7130 Token xsp;
7131 xsp = jj_scanpos;
7132 jj_lookingAhead = true;
7133 jj_semLA = isNamespaceFuncall(getToken(1), getToken(2), getToken(3), getToken(4));
7134 jj_lookingAhead = false;
7135 if (!jj_semLA || jj_3R_161()) {
7136 jj_scanpos = xsp;
7137 if (jj_3_75()) {
7138 jj_scanpos = xsp;
7139 if (jj_3_76()) return true;
7140 }
7141 }
7142 return false;
7143 }
7144
7145 private boolean jj_3R_161()
7146 {
7147 if (jj_scan_token(IDENTIFIER)) return true;
7148 if (jj_scan_token(COLON)) return true;
7149 if (jj_scan_token(IDENTIFIER)) return true;
7150 if (jj_scan_token(LPAREN)) return true;
7151 return false;
7152 }
7153
7154 private boolean jj_3_75()
7155 {
7156 if (jj_scan_token(IDENTIFIER)) return true;
7157 if (jj_scan_token(LPAREN)) return true;
7158 return false;
7159 }
7160
7161 private boolean jj_3_76()
7162 {
7163 if (jj_scan_token(REGISTER)) return true;
7164 if (jj_scan_token(LPAREN)) return true;
7165 return false;
7166 }
7167
7168 private boolean jj_3_73()
7169 {
7170 if (jj_3R_41()) return true;
7171 Token xsp;
7172 while (true) {
7173 xsp = jj_scanpos;
7174 if (jj_3R_295()) { jj_scanpos = xsp; break; }
7175 }
7176 return false;
7177 }
7178
7179 private boolean jj_3R_230()
7180 {
7181 Token xsp;
7182 xsp = jj_scanpos;
7183 jj_lookingAhead = true;
7184 jj_semLA = isNamespaceFuncall(getToken(1), getToken(2), getToken(3), getToken(4));
7185 jj_lookingAhead = false;
7186 if (!jj_semLA || jj_3R_239()) {
7187 jj_scanpos = xsp;
7188 if (jj_3R_240()) return true;
7189 }
7190 return false;
7191 }
7192
7193 private boolean jj_3R_239()
7194 {
7195 if (jj_3R_256()) return true;
7196 if (jj_3R_42()) return true;
7197 return false;
7198 }
7199
7200 private boolean jj_3R_240()
7201 {
7202 if (jj_3R_111()) return true;
7203 if (jj_3R_42()) return true;
7204 return false;
7205 }
7206
7207 private boolean jj_3_74()
7208 {
7209 if (jj_scan_token(IDENTIFIER)) return true;
7210 if (jj_scan_token(COLON)) return true;
7211 if (jj_scan_token(IDENTIFIER)) return true;
7212 if (jj_scan_token(LPAREN)) return true;
7213 return false;
7214 }
7215
7216 private boolean jj_3R_286()
7217 {
7218 if (jj_3R_184()) return true;
7219 return false;
7220 }
7221
7222 private boolean jj_3R_295()
7223 {
7224 if (jj_scan_token(COMMA)) return true;
7225 if (jj_3R_41()) return true;
7226 return false;
7227 }
7228
7229 private boolean jj_3_78()
7230 {
7231 if (jj_scan_token(IDENTIFIER)) return true;
7232 if (jj_scan_token(LPAREN)) return true;
7233 return false;
7234 }
7235
7236 private boolean jj_3_80()
7237 {
7238 if (jj_scan_token(NEW)) return true;
7239 if (jj_scan_token(LPAREN)) return true;
7240 if (jj_3R_41()) return true;
7241 Token xsp;
7242 while (true) {
7243 xsp = jj_scanpos;
7244 if (jj_3R_285()) { jj_scanpos = xsp; break; }
7245 }
7246 if (jj_scan_token(RPAREN)) return true;
7247 return false;
7248 }
7249
7250 private boolean jj_3R_228()
7251 {
7252 Token xsp;
7253 xsp = jj_scanpos;
7254 if (jj_3_80()) {
7255 jj_scanpos = xsp;
7256 if (jj_3R_238()) return true;
7257 }
7258 return false;
7259 }
7260
7261 private boolean jj_3_77()
7262 {
7263 if (jj_scan_token(IDENTIFIER)) return true;
7264 if (jj_scan_token(COLON)) return true;
7265 if (jj_scan_token(IDENTIFIER)) return true;
7266 if (jj_scan_token(LPAREN)) return true;
7267 return false;
7268 }
7269
7270 private boolean jj_3R_238()
7271 {
7272 if (jj_scan_token(NEW)) return true;
7273 if (jj_3R_286()) return true;
7274 if (jj_scan_token(LPAREN)) return true;
7275 Token xsp;
7276 xsp = jj_scanpos;
7277 if (jj_3_79()) jj_scanpos = xsp;
7278 if (jj_scan_token(RPAREN)) return true;
7279 return false;
7280 }
7281
7282 private boolean jj_3R_221()
7283 {
7284 Token xsp;
7285 xsp = jj_scanpos;
7286 if (jj_3R_234()) {
7287 jj_scanpos = xsp;
7288 if (jj_3R_235()) {
7289 jj_scanpos = xsp;
7290 if (jj_3R_236()) return true;
7291 }
7292 }
7293 return false;
7294 }
7295
7296 private boolean jj_3R_234()
7297 {
7298 Token xsp;
7299 xsp = jj_scanpos;
7300 if (jj_scan_token(101)) jj_scanpos = xsp;
7301 if (jj_scan_token(IDENTIFIER)) return true;
7302 return false;
7303 }
7304
7305 private boolean jj_3R_235()
7306 {
7307 if (jj_scan_token(LET)) return true;
7308 if (jj_scan_token(IDENTIFIER)) return true;
7309 return false;
7310 }
7311
7312 private boolean jj_3R_236()
7313 {
7314 if (jj_scan_token(CONST)) return true;
7315 if (jj_scan_token(IDENTIFIER)) return true;
7316 return false;
7317 }
7318
7319 private boolean jj_3R_122()
7320 {
7321 if (jj_scan_token(LPAREN)) return true;
7322 Token xsp;
7323 xsp = jj_scanpos;
7324 if (jj_3R_273()) jj_scanpos = xsp;
7325 if (jj_scan_token(RPAREN)) return true;
7326 return false;
7327 }
7328
7329 private boolean jj_3R_182()
7330 {
7331 if (jj_scan_token(LPAREN)) return true;
7332 Token xsp;
7333 xsp = jj_scanpos;
7334 if (jj_3R_204()) jj_scanpos = xsp;
7335 if (jj_scan_token(RPAREN)) return true;
7336 return false;
7337 }
7338
7339 private boolean jj_3R_49()
7340 {
7341 Token xsp;
7342 xsp = jj_scanpos;
7343 if (jj_3R_137()) {
7344 jj_scanpos = xsp;
7345 if (jj_3R_138()) {
7346 jj_scanpos = xsp;
7347 if (jj_3R_139()) return true;
7348 }
7349 }
7350 return false;
7351 }
7352
7353 private boolean jj_3R_137()
7354 {
7355 if (jj_scan_token(FUNCTION)) return true;
7356 if (jj_3R_182()) return true;
7357 return false;
7358 }
7359
7360 private boolean jj_3R_138()
7361 {
7362 if (jj_3R_182()) return true;
7363 Token xsp;
7364 xsp = jj_scanpos;
7365 if (jj_scan_token(86)) {
7366 jj_scanpos = xsp;
7367 if (jj_scan_token(87)) return true;
7368 }
7369 return false;
7370 }
7371
7372 private boolean jj_3R_273()
7373 {
7374 if (jj_3R_221()) return true;
7375 Token xsp;
7376 while (true) {
7377 xsp = jj_scanpos;
7378 if (jj_3R_294()) { jj_scanpos = xsp; break; }
7379 }
7380 return false;
7381 }
7382
7383 private boolean jj_3R_139()
7384 {
7385 if (jj_scan_token(IDENTIFIER)) return true;
7386 Token xsp;
7387 xsp = jj_scanpos;
7388 if (jj_scan_token(86)) {
7389 jj_scanpos = xsp;
7390 if (jj_scan_token(87)) return true;
7391 }
7392 return false;
7393 }
7394
7395 private boolean jj_3R_204()
7396 {
7397 Token xsp;
7398 xsp = jj_scanpos;
7399 if (jj_3R_222()) jj_scanpos = xsp;
7400 if (jj_scan_token(IDENTIFIER)) return true;
7401 while (true) {
7402 xsp = jj_scanpos;
7403 if (jj_3R_223()) { jj_scanpos = xsp; break; }
7404 }
7405 return false;
7406 }
7407
7408 private boolean jj_3R_222()
7409 {
7410 Token xsp;
7411 xsp = jj_scanpos;
7412 if (jj_scan_token(101)) {
7413 jj_scanpos = xsp;
7414 if (jj_scan_token(102)) {
7415 jj_scanpos = xsp;
7416 if (jj_scan_token(103)) return true;
7417 }
7418 }
7419 return false;
7420 }
7421
7422 private boolean jj_3R_181()
7423 {
7424 Token xsp;
7425 xsp = jj_scanpos;
7426 if (jj_3R_201()) {
7427 jj_scanpos = xsp;
7428 if (jj_3R_202()) {
7429 jj_scanpos = xsp;
7430 if (jj_3R_203()) return true;
7431 }
7432 }
7433 return false;
7434 }
7435
7436 private boolean jj_3R_201()
7437 {
7438 if (jj_scan_token(FUNCTION)) return true;
7439 Token xsp;
7440 xsp = jj_scanpos;
7441 if (jj_3R_272()) jj_scanpos = xsp;
7442 if (jj_3R_122()) return true;
7443 xsp = jj_scanpos;
7444 if (jj_3_82()) {
7445 jj_scanpos = xsp;
7446 if (jj_3_83()) return true;
7447 }
7448 return false;
7449 }
7450
7451 private boolean jj_3_79()
7452 {
7453 if (jj_3R_41()) return true;
7454 Token xsp;
7455 while (true) {
7456 xsp = jj_scanpos;
7457 if (jj_3R_292()) { jj_scanpos = xsp; break; }
7458 }
7459 return false;
7460 }
7461
7462 private boolean jj_3R_285()
7463 {
7464 if (jj_scan_token(COMMA)) return true;
7465 if (jj_3R_41()) return true;
7466 return false;
7467 }
7468
7469 private boolean jj_3R_202()
7470 {
7471 if (jj_3R_122()) return true;
7472 Token xsp;
7473 xsp = jj_scanpos;
7474 if (jj_scan_token(86)) {
7475 jj_scanpos = xsp;
7476 if (jj_scan_token(87)) return true;
7477 }
7478 xsp = jj_scanpos;
7479 if (jj_3_84()) {
7480 jj_scanpos = xsp;
7481 if (jj_3_85()) return true;
7482 }
7483 return false;
7484 }
7485
7486 private boolean jj_3R_294()
7487 {
7488 if (jj_scan_token(COMMA)) return true;
7489 if (jj_3R_221()) return true;
7490 return false;
7491 }
7492
7493 private boolean jj_3R_203()
7494 {
7495 if (jj_3R_221()) return true;
7496 Token xsp;
7497 xsp = jj_scanpos;
7498 if (jj_scan_token(86)) {
7499 jj_scanpos = xsp;
7500 if (jj_scan_token(87)) return true;
7501 }
7502 xsp = jj_scanpos;
7503 if (jj_3_86()) {
7504 jj_scanpos = xsp;
7505 if (jj_3_87()) return true;
7506 }
7507 return false;
7508 }
7509
7510 private boolean jj_3R_272()
7511 {
7512 if (jj_3R_121()) return true;
7513 return false;
7514 }
7515
7516 private boolean jj_3R_292()
7517 {
7518 if (jj_scan_token(COMMA)) return true;
7519 if (jj_3R_41()) return true;
7520 return false;
7521 }
7522
7523 private boolean jj_3R_220()
7524 {
7525 Token xsp;
7526 xsp = jj_scanpos;
7527 if (jj_3R_232()) {
7528 jj_scanpos = xsp;
7529 if (jj_3R_233()) return true;
7530 }
7531 return false;
7532 }
7533
7534 private boolean jj_3R_232()
7535 {
7536 if (jj_scan_token(DOT)) return true;
7537 Token xsp;
7538 xsp = jj_scanpos;
7539 if (jj_3R_249()) {
7540 jj_scanpos = xsp;
7541 if (jj_3R_250()) {
7542 jj_scanpos = xsp;
7543 if (jj_3R_251()) return true;
7544 }
7545 }
7546 return false;
7547 }
7548
7549 private boolean jj_3_81()
7550 {
7551 if (jj_scan_token(IDENTIFIER)) return true;
7552 return false;
7553 }
7554
7555 private boolean jj_3R_249()
7556 {
7557 if (jj_scan_token(DOT_IDENTIFIER)) return true;
7558 return false;
7559 }
7560
7561 private boolean jj_3R_250()
7562 {
7563 if (jj_scan_token(STRING_LITERAL)) return true;
7564 return false;
7565 }
7566
7567 private boolean jj_3R_233()
7568 {
7569 if (jj_scan_token(QDOT)) return true;
7570 Token xsp;
7571 xsp = jj_scanpos;
7572 if (jj_3R_252()) {
7573 jj_scanpos = xsp;
7574 if (jj_3R_253()) {
7575 jj_scanpos = xsp;
7576 if (jj_3R_254()) return true;
7577 }
7578 }
7579 return false;
7580 }
7581
7582 private boolean jj_3R_251()
7583 {
7584 if (jj_scan_token(JXLT_LITERAL)) return true;
7585 return false;
7586 }
7587
7588 private boolean jj_3R_223()
7589 {
7590 if (jj_scan_token(COMMA)) return true;
7591 Token xsp;
7592 xsp = jj_scanpos;
7593 if (jj_3R_237()) jj_scanpos = xsp;
7594 if (jj_scan_token(IDENTIFIER)) return true;
7595 return false;
7596 }
7597
7598 private boolean jj_3R_252()
7599 {
7600 if (jj_scan_token(DOT_IDENTIFIER)) return true;
7601 return false;
7602 }
7603
7604 private boolean jj_3R_253()
7605 {
7606 if (jj_scan_token(STRING_LITERAL)) return true;
7607 return false;
7608 }
7609
7610 private boolean jj_3R_254()
7611 {
7612 if (jj_scan_token(JXLT_LITERAL)) return true;
7613 return false;
7614 }
7615
7616 private boolean jj_3_82()
7617 {
7618 if (jj_3R_51()) return true;
7619 return false;
7620 }
7621
7622 private boolean jj_3R_219()
7623 {
7624 Token xsp;
7625 if (jj_3_88()) return true;
7626 while (true) {
7627 xsp = jj_scanpos;
7628 if (jj_3_88()) { jj_scanpos = xsp; break; }
7629 }
7630 return false;
7631 }
7632
7633 private boolean jj_3R_237()
7634 {
7635 Token xsp;
7636 xsp = jj_scanpos;
7637 if (jj_scan_token(101)) {
7638 jj_scanpos = xsp;
7639 if (jj_scan_token(102)) {
7640 jj_scanpos = xsp;
7641 if (jj_scan_token(103)) return true;
7642 }
7643 }
7644 return false;
7645 }
7646
7647 private boolean jj_3_88()
7648 {
7649 Token xsp;
7650 xsp = jj_scanpos;
7651 if (jj_scan_token(18)) {
7652 jj_scanpos = xsp;
7653 if (jj_3R_112()) return true;
7654 }
7655 if (jj_3R_41()) return true;
7656 if (jj_scan_token(RBRACKET)) return true;
7657 return false;
7658 }
7659
7660 private boolean jj_3R_162()
7661 {
7662 Token xsp;
7663 xsp = jj_scanpos;
7664 if (jj_3R_194()) {
7665 jj_scanpos = xsp;
7666 if (jj_3R_195()) {
7667 jj_scanpos = xsp;
7668 if (jj_3R_196()) return true;
7669 }
7670 }
7671 return false;
7672 }
7673
7674 private boolean jj_3R_194()
7675 {
7676 if (jj_3R_219()) return true;
7677 return false;
7678 }
7679
7680 private boolean jj_3R_195()
7681 {
7682 if (jj_3R_220()) return true;
7683 return false;
7684 }
7685
7686 private boolean jj_3R_196()
7687 {
7688 if (jj_3R_220()) return true;
7689 return false;
7690 }
7691
7692 private boolean jj_3R_224()
7693 {
7694 if (jj_scan_token(LPAREN)) return true;
7695 if (jj_3R_41()) return true;
7696 if (jj_scan_token(RPAREN)) return true;
7697 Token xsp;
7698 while (true) {
7699 xsp = jj_scanpos;
7700 if (jj_3R_278()) { jj_scanpos = xsp; break; }
7701 }
7702 return false;
7703 }
7704
7705 private boolean jj_3_89()
7706 {
7707 Token xsp;
7708 xsp = jj_scanpos;
7709 if (jj_scan_token(18)) {
7710 jj_scanpos = xsp;
7711 if (jj_scan_token(19)) return true;
7712 }
7713 return false;
7714 }
7715
7716 private boolean jj_3_90()
7717 {
7718 if (jj_scan_token(DOT)) return true;
7719 return false;
7720 }
7721
7722 private boolean jj_3_91()
7723 {
7724 if (jj_scan_token(QDOT)) return true;
7725 return false;
7726 }
7727
7728 private boolean jj_3_83()
7729 {
7730 if (jj_3R_41()) return true;
7731 return false;
7732 }
7733
7734 private boolean jj_3R_193()
7735 {
7736 Token xsp;
7737 xsp = jj_scanpos;
7738 if (jj_3R_207()) {
7739 jj_scanpos = xsp;
7740 if (jj_3R_208()) {
7741 jj_scanpos = xsp;
7742 if (jj_3R_209()) {
7743 jj_scanpos = xsp;
7744 if (jj_3R_210()) {
7745 jj_scanpos = xsp;
7746 if (jj_3R_211()) {
7747 jj_scanpos = xsp;
7748 if (jj_3R_212()) {
7749 jj_scanpos = xsp;
7750 if (jj_3R_213()) {
7751 jj_scanpos = xsp;
7752 if (jj_3R_214()) {
7753 jj_scanpos = xsp;
7754 if (jj_3R_215()) {
7755 jj_scanpos = xsp;
7756 if (jj_3R_216()) {
7757 jj_scanpos = xsp;
7758 if (jj_3R_217()) {
7759 jj_scanpos = xsp;
7760 if (jj_3R_218()) return true;
7761 }
7762 }
7763 }
7764 }
7765 }
7766 }
7767 }
7768 }
7769 }
7770 }
7771 }
7772 return false;
7773 }
7774
7775 private boolean jj_3R_207()
7776 {
7777 if (jj_3R_181()) return true;
7778 return false;
7779 }
7780
7781 private boolean jj_3R_208()
7782 {
7783 if (jj_3R_224()) return true;
7784 return false;
7785 }
7786
7787 private boolean jj_3R_112()
7788 {
7789 if (jj_scan_token(QLBRACKET)) return true;
7790 return false;
7791 }
7792
7793 private boolean jj_3R_209()
7794 {
7795 if (jj_3R_225()) return true;
7796 return false;
7797 }
7798
7799 private boolean jj_3R_210()
7800 {
7801 if (jj_3R_225()) return true;
7802 return false;
7803 }
7804
7805 private boolean jj_3R_211()
7806 {
7807 if (jj_3R_226()) return true;
7808 return false;
7809 }
7810
7811 private boolean jj_3R_212()
7812 {
7813 if (jj_3R_226()) return true;
7814 return false;
7815 }
7816
7817 private boolean jj_3_93()
7818 {
7819 if (jj_3R_49()) return true;
7820 return false;
7821 }
7822
7823 private boolean jj_3R_213()
7824 {
7825 if (jj_3R_227()) return true;
7826 return false;
7827 }
7828
7829 private boolean jj_3_94()
7830 {
7831 if (jj_scan_token(LPAREN)) return true;
7832 return false;
7833 }
7834
7835 private boolean jj_3R_214()
7836 {
7837 if (jj_3R_228()) return true;
7838 return false;
7839 }
7840
7841 private boolean jj_3_84()
7842 {
7843 if (jj_3R_51()) return true;
7844 return false;
7845 }
7846
7847 private boolean jj_3_86()
7848 {
7849 if (jj_3R_51()) return true;
7850 return false;
7851 }
7852
7853 private boolean jj_3_95()
7854 {
7855 if (jj_scan_token(LCURLY)) return true;
7856 if (jj_3R_41()) return true;
7857 if (jj_scan_token(COLON)) return true;
7858 return false;
7859 }
7860
7861 private boolean jj_3R_215()
7862 {
7863 if (jj_3R_229()) return true;
7864 return false;
7865 }
7866
7867 private boolean jj_3_96()
7868 {
7869 if (jj_scan_token(LCURLY)) return true;
7870 if (jj_scan_token(COLON)) return true;
7871 return false;
7872 }
7873
7874 private boolean jj_3R_216()
7875 {
7876 if (jj_3R_230()) return true;
7877 return false;
7878 }
7879
7880 private boolean jj_3_97()
7881 {
7882 if (jj_scan_token(LCURLY)) return true;
7883 if (jj_3R_41()) return true;
7884 Token xsp;
7885 xsp = jj_scanpos;
7886 if (jj_scan_token(23)) {
7887 jj_scanpos = xsp;
7888 if (jj_scan_token(17)) return true;
7889 }
7890 return false;
7891 }
7892
7893 private boolean jj_3R_217()
7894 {
7895 if (jj_3R_111()) return true;
7896 return false;
7897 }
7898
7899 private boolean jj_3_98()
7900 {
7901 if (jj_scan_token(LCURLY)) return true;
7902 if (jj_scan_token(RCURLY)) return true;
7903 return false;
7904 }
7905
7906 private boolean jj_3R_218()
7907 {
7908 if (jj_3R_231()) return true;
7909 return false;
7910 }
7911
7912 private boolean jj_3_99()
7913 {
7914 if (jj_scan_token(LBRACKET)) return true;
7915 return false;
7916 }
7917
7918 private boolean jj_3R_197()
7919 {
7920 if (jj_3R_162()) return true;
7921 Token xsp;
7922 if (jj_3R_288()) return true;
7923 while (true) {
7924 xsp = jj_scanpos;
7925 if (jj_3R_288()) { jj_scanpos = xsp; break; }
7926 }
7927 return false;
7928 }
7929
7930 private boolean jj_3_100()
7931 {
7932 if (jj_scan_token(NEW)) return true;
7933 return false;
7934 }
7935
7936 private boolean jj_3_101()
7937 {
7938 if (jj_scan_token(SWITCH)) return true;
7939 return false;
7940 }
7941
7942 private boolean jj_3_102()
7943 {
7944 if (jj_3R_113()) return true;
7945 return false;
7946 }
7947
7948 private boolean jj_3R_114()
7949 {
7950 if (jj_3R_162()) return true;
7951 if (jj_scan_token(LPAREN)) return true;
7952 return false;
7953 }
7954
7955 private boolean jj_3R_115()
7956 {
7957 Token xsp;
7958 xsp = jj_scanpos;
7959 if (jj_3R_163()) {
7960 jj_scanpos = xsp;
7961 if (jj_3R_164()) return true;
7962 }
7963 return false;
7964 }
7965
7966 private boolean jj_3R_163()
7967 {
7968 if (jj_3R_197()) return true;
7969 return false;
7970 }
7971
7972 private boolean jj_3_85()
7973 {
7974 if (jj_3R_41()) return true;
7975 return false;
7976 }
7977
7978 private boolean jj_3_87()
7979 {
7980 if (jj_3R_41()) return true;
7981 return false;
7982 }
7983
7984 private boolean jj_3R_158()
7985 {
7986 if (jj_3R_193()) return true;
7987 Token xsp;
7988 while (true) {
7989 xsp = jj_scanpos;
7990 if (jj_3_105()) { jj_scanpos = xsp; break; }
7991 }
7992 return false;
7993 }
7994
7995 private boolean jj_3R_288()
7996 {
7997 if (jj_3R_42()) return true;
7998 return false;
7999 }
8000
8001 private boolean jj_3_104()
8002 {
8003 if (jj_3R_114()) return true;
8004 return false;
8005 }
8006
8007 private boolean jj_3R_278()
8008 {
8009 if (jj_3R_42()) return true;
8010 return false;
8011 }
8012
8013 private boolean jj_3_103()
8014 {
8015 if (jj_scan_token(LPAREN)) return true;
8016 return false;
8017 }
8018
8019 private boolean jj_3_92()
8020 {
8021 if (jj_scan_token(LPAREN)) return true;
8022 return false;
8023 }
8024
8025 private boolean jj_3_105()
8026 {
8027 if (jj_3R_115()) return true;
8028 return false;
8029 }
8030
8031 private boolean jj_3R_164()
8032 {
8033 if (jj_3R_162()) return true;
8034 return false;
8035 }
8036
8037 private boolean jj_3_1()
8038 {
8039 Token xsp;
8040 xsp = jj_scanpos;
8041 if (jj_3R_39()) {
8042 jj_scanpos = xsp;
8043 if (jj_3_2()) return true;
8044 }
8045 return false;
8046 }
8047
8048 private boolean jj_3R_39()
8049 {
8050 if (jj_3R_116()) return true;
8051 return false;
8052 }
8053
8054 private boolean jj_3R_43()
8055 {
8056 if (jj_scan_token(ANNOTATION)) return true;
8057 Token xsp;
8058 xsp = jj_scanpos;
8059 if (jj_3_4()) jj_scanpos = xsp;
8060 return false;
8061 }
8062
8063 private boolean jj_3_2()
8064 {
8065 if (jj_3R_40()) return true;
8066 return false;
8067 }
8068
8069 private boolean jj_3R_171()
8070 {
8071 Token xsp;
8072 if (jj_3_5()) return true;
8073 while (true) {
8074 xsp = jj_scanpos;
8075 if (jj_3_5()) { jj_scanpos = xsp; break; }
8076 }
8077 xsp = jj_scanpos;
8078 if (jj_3R_267()) {
8079 jj_scanpos = xsp;
8080 if (jj_3_7()) return true;
8081 }
8082 return false;
8083 }
8084
8085 private boolean jj_3_5()
8086 {
8087 if (jj_3R_43()) return true;
8088 return false;
8089 }
8090
8091 private boolean jj_3R_267()
8092 {
8093 if (jj_3R_41()) return true;
8094 return false;
8095 }
8096
8097 private boolean jj_3_8()
8098 {
8099 if (jj_3R_45()) return true;
8100 return false;
8101 }
8102
8103 private boolean jj_3R_40()
8104 {
8105 Token xsp;
8106 xsp = jj_scanpos;
8107 if (jj_3_8()) {
8108 jj_scanpos = xsp;
8109 if (jj_3_9()) {
8110 jj_scanpos = xsp;
8111 if (jj_3_10()) return true;
8112 }
8113 }
8114 return false;
8115 }
8116
8117 private boolean jj_3_7()
8118 {
8119 if (jj_3R_40()) return true;
8120 return false;
8121 }
8122
8123 private boolean jj_3_9()
8124 {
8125 if (jj_3R_46()) return true;
8126 return false;
8127 }
8128
8129 private boolean jj_3_10()
8130 {
8131 if (jj_3R_47()) return true;
8132 return false;
8133 }
8134
8135 private boolean jj_3_6()
8136 {
8137 if (jj_scan_token(LCURLY)) return true;
8138 Token xsp;
8139 xsp = jj_scanpos;
8140 if (jj_scan_token(17)) {
8141 jj_scanpos = xsp;
8142 if (jj_scan_token(22)) {
8143 jj_scanpos = xsp;
8144 if (jj_3R_44()) return true;
8145 }
8146 }
8147 return false;
8148 }
8149
8150 private boolean jj_3R_47()
8151 {
8152 Token xsp;
8153 xsp = jj_scanpos;
8154 if (jj_scan_token(21)) {
8155 jj_scanpos = xsp;
8156 if (jj_3R_123()) {
8157 jj_scanpos = xsp;
8158 if (jj_3R_124()) {
8159 jj_scanpos = xsp;
8160 if (jj_3R_125()) {
8161 jj_scanpos = xsp;
8162 if (jj_3R_126()) {
8163 jj_scanpos = xsp;
8164 if (jj_3R_127()) {
8165 jj_scanpos = xsp;
8166 if (jj_3R_128()) {
8167 jj_scanpos = xsp;
8168 if (jj_3R_129()) {
8169 jj_scanpos = xsp;
8170 if (jj_3R_130()) {
8171 jj_scanpos = xsp;
8172 if (jj_3R_131()) {
8173 jj_scanpos = xsp;
8174 if (jj_3R_132()) {
8175 jj_scanpos = xsp;
8176 if (jj_3_11()) {
8177 jj_scanpos = xsp;
8178 if (jj_3R_133()) {
8179 jj_scanpos = xsp;
8180 if (jj_3R_134()) {
8181 jj_scanpos = xsp;
8182 if (jj_3R_135()) {
8183 jj_scanpos = xsp;
8184 jj_lookingAhead = true;
8185 jj_semLA = !getFeatures().isLexical();
8186 jj_lookingAhead = false;
8187 if (!jj_semLA || jj_3R_136()) return true;
8188 }
8189 }
8190 }
8191 }
8192 }
8193 }
8194 }
8195 }
8196 }
8197 }
8198 }
8199 }
8200 }
8201 }
8202 }
8203 return false;
8204 }
8205
8206 private boolean jj_3R_123()
8207 {
8208 if (jj_3R_171()) return true;
8209 return false;
8210 }
8211
8212 private boolean jj_3R_124()
8213 {
8214 if (jj_3R_172()) return true;
8215 return false;
8216 }
8217
8218 private boolean jj_3R_125()
8219 {
8220 if (jj_3R_173()) return true;
8221 return false;
8222 }
8223
8224 private boolean jj_3R_126()
8225 {
8226 if (jj_3R_174()) return true;
8227 return false;
8228 }
8229
8230 private boolean jj_3R_127()
8231 {
8232 if (jj_3R_175()) return true;
8233 return false;
8234 }
8235
8236 private boolean jj_3R_128()
8237 {
8238 if (jj_3R_176()) return true;
8239 return false;
8240 }
8241
8242 private boolean jj_3_3()
8243 {
8244 if (jj_3R_41()) return true;
8245 return false;
8246 }
8247
8248 private boolean jj_3R_129()
8249 {
8250 if (jj_3R_177()) return true;
8251 return false;
8252 }
8253
8254 private boolean jj_3R_130()
8255 {
8256 if (jj_3R_178()) return true;
8257 return false;
8258 }
8259
8260 private boolean jj_3R_131()
8261 {
8262 if (jj_3R_179()) return true;
8263 return false;
8264 }
8265
8266 private boolean jj_3R_132()
8267 {
8268 if (jj_3R_180()) return true;
8269 return false;
8270 }
8271
8272 private boolean jj_3_11()
8273 {
8274 if (jj_3R_48()) return true;
8275 return false;
8276 }
8277
8278 private boolean jj_3R_133()
8279 {
8280 if (jj_3R_181()) return true;
8281 return false;
8282 }
8283
8284 private boolean jj_3R_134()
8285 {
8286 if (jj_3R_53()) return true;
8287 return false;
8288 }
8289
8290 private boolean jj_3R_135()
8291 {
8292 if (jj_3R_51()) return true;
8293 return false;
8294 }
8295
8296 private boolean jj_3R_136()
8297 {
8298 if (jj_3R_45()) return true;
8299 return false;
8300 }
8301
8302 private boolean jj_3R_51()
8303 {
8304 if (jj_scan_token(LCURLY)) return true;
8305 Token xsp;
8306 while (true) {
8307 xsp = jj_scanpos;
8308 if (jj_3_15()) { jj_scanpos = xsp; break; }
8309 }
8310 if (jj_scan_token(RCURLY)) return true;
8311 return false;
8312 }
8313
8314 private boolean jj_3R_46()
8315 {
8316 if (jj_scan_token(FUNCTION)) return true;
8317 if (jj_3R_121()) return true;
8318 if (jj_3R_122()) return true;
8319 Token xsp;
8320 xsp = jj_scanpos;
8321 if (jj_3_17()) {
8322 jj_scanpos = xsp;
8323 if (jj_3_18()) return true;
8324 }
8325 return false;
8326 }
8327
8328 private boolean jj_3_4()
8329 {
8330 if (jj_3R_42()) return true;
8331 return false;
8332 }
8333
8334 private boolean jj_3_12()
8335 {
8336 if (jj_3R_49()) return true;
8337 return false;
8338 }
8339
8340 private boolean jj_3_13()
8341 {
8342 if (jj_3R_41()) return true;
8343 return false;
8344 }
8345
8346 private boolean jj_3_14()
8347 {
8348 if (jj_scan_token(VAR)) return true;
8349 return false;
8350 }
8351
8352 private boolean jj_3R_53()
8353 {
8354 if (jj_3R_41()) return true;
8355 Token xsp;
8356 while (true) {
8357 xsp = jj_scanpos;
8358 if (jj_3_19()) { jj_scanpos = xsp; break; }
8359 }
8360 xsp = jj_scanpos;
8361 if (jj_scan_token(21)) jj_scanpos = xsp;
8362 return false;
8363 }
8364
8365 private boolean jj_3R_44()
8366 {
8367 if (jj_3R_41()) return true;
8368 Token xsp;
8369 xsp = jj_scanpos;
8370 if (jj_scan_token(17)) {
8371 jj_scanpos = xsp;
8372 if (jj_scan_token(22)) {
8373 jj_scanpos = xsp;
8374 if (jj_scan_token(23)) return true;
8375 }
8376 }
8377 return false;
8378 }
8379
8380 private boolean jj_3R_172()
8381 {
8382 if (jj_scan_token(IF)) return true;
8383 if (jj_scan_token(LPAREN)) return true;
8384 if (jj_3R_41()) return true;
8385 if (jj_scan_token(RPAREN)) return true;
8386 Token xsp;
8387 xsp = jj_scanpos;
8388 if (jj_3R_305()) {
8389 jj_scanpos = xsp;
8390 if (jj_3_20()) return true;
8391 }
8392 while (true) {
8393 xsp = jj_scanpos;
8394 if (jj_3_21()) { jj_scanpos = xsp; break; }
8395 }
8396 xsp = jj_scanpos;
8397 if (jj_3R_306()) jj_scanpos = xsp;
8398 return false;
8399 }
8400
8401 private boolean jj_3_21()
8402 {
8403 if (jj_scan_token(ELSE)) return true;
8404 if (jj_scan_token(IF)) return true;
8405 if (jj_scan_token(LPAREN)) return true;
8406 if (jj_3R_41()) return true;
8407 if (jj_scan_token(RPAREN)) return true;
8408 Token xsp;
8409 xsp = jj_scanpos;
8410 if (jj_3R_313()) {
8411 jj_scanpos = xsp;
8412 if (jj_3_22()) return true;
8413 }
8414 return false;
8415 }
8416
8417 private boolean jj_3R_306()
8418 {
8419 if (jj_scan_token(ELSE)) return true;
8420 Token xsp;
8421 xsp = jj_scanpos;
8422 if (jj_3R_314()) {
8423 jj_scanpos = xsp;
8424 if (jj_3_23()) return true;
8425 }
8426 return false;
8427 }
8428
8429 private boolean jj_3_19()
8430 {
8431 if (jj_3R_41()) return true;
8432 return false;
8433 }
8434
8435 private boolean jj_3R_180()
8436 {
8437 if (jj_scan_token(TRY)) return true;
8438 Token xsp;
8439 xsp = jj_scanpos;
8440 if (jj_3R_269()) {
8441 jj_scanpos = xsp;
8442 if (jj_3R_270()) return true;
8443 }
8444 xsp = jj_scanpos;
8445 if (jj_3R_309()) jj_scanpos = xsp;
8446 xsp = jj_scanpos;
8447 if (jj_3R_310()) jj_scanpos = xsp;
8448 return false;
8449 }
8450
8451 private boolean jj_3R_309()
8452 {
8453 if (jj_scan_token(CATCH)) return true;
8454 if (jj_scan_token(LPAREN)) return true;
8455 if (jj_3R_55()) return true;
8456 if (jj_scan_token(RPAREN)) return true;
8457 if (jj_3R_51()) return true;
8458 return false;
8459 }
8460
8461 private boolean jj_3R_310()
8462 {
8463 if (jj_scan_token(FINALLY)) return true;
8464 if (jj_3R_51()) return true;
8465 return false;
8466 }
8467
8468 private boolean jj_3R_271()
8469 {
8470 if (jj_scan_token(LPAREN)) return true;
8471 if (jj_3R_52()) return true;
8472 Token xsp;
8473 while (true) {
8474 xsp = jj_scanpos;
8475 if (jj_3_24()) { jj_scanpos = xsp; break; }
8476 }
8477 xsp = jj_scanpos;
8478 if (jj_scan_token(21)) jj_scanpos = xsp;
8479 if (jj_scan_token(RPAREN)) return true;
8480 if (jj_3R_51()) return true;
8481 return false;
8482 }
8483
8484 private boolean jj_3R_269()
8485 {
8486 if (jj_3R_271()) return true;
8487 return false;
8488 }
8489
8490 private boolean jj_3_15()
8491 {
8492 Token xsp;
8493 xsp = jj_scanpos;
8494 if (jj_3R_50()) {
8495 jj_scanpos = xsp;
8496 if (jj_3_16()) return true;
8497 }
8498 return false;
8499 }
8500
8501 private boolean jj_3R_50()
8502 {
8503 if (jj_3R_116()) return true;
8504 return false;
8505 }
8506
8507 private boolean jj_3_25()
8508 {
8509 if (jj_3R_45()) return true;
8510 return false;
8511 }
8512
8513 private boolean jj_3R_52()
8514 {
8515 Token xsp;
8516 xsp = jj_scanpos;
8517 if (jj_3_25()) {
8518 jj_scanpos = xsp;
8519 if (jj_3R_140()) return true;
8520 }
8521 return false;
8522 }
8523
8524 private boolean jj_3R_314()
8525 {
8526 if (jj_3R_51()) return true;
8527 return false;
8528 }
8529
8530 private boolean jj_3_16()
8531 {
8532 if (jj_3R_40()) return true;
8533 return false;
8534 }
8535
8536 private boolean jj_3R_174()
8537 {
8538 if (jj_scan_token(WHILE)) return true;
8539 if (jj_scan_token(LPAREN)) return true;
8540 if (jj_3R_41()) return true;
8541 if (jj_scan_token(RPAREN)) return true;
8542 Token xsp;
8543 xsp = jj_scanpos;
8544 if (jj_3R_308()) {
8545 jj_scanpos = xsp;
8546 if (jj_3_26()) return true;
8547 }
8548 return false;
8549 }
8550
8551 private boolean jj_3R_270()
8552 {
8553 if (jj_3R_51()) return true;
8554 return false;
8555 }
8556
8557 private boolean jj_3_24()
8558 {
8559 if (jj_scan_token(SEMICOL)) return true;
8560 if (jj_3R_52()) return true;
8561 return false;
8562 }
8563
8564 private boolean jj_3R_305()
8565 {
8566 if (jj_3R_51()) return true;
8567 return false;
8568 }
8569
8570 private boolean jj_3R_175()
8571 {
8572 if (jj_scan_token(DO)) return true;
8573 Token xsp;
8574 xsp = jj_scanpos;
8575 if (jj_3R_268()) {
8576 jj_scanpos = xsp;
8577 if (jj_3_27()) return true;
8578 }
8579 if (jj_scan_token(WHILE)) return true;
8580 if (jj_scan_token(LPAREN)) return true;
8581 if (jj_3R_41()) return true;
8582 if (jj_scan_token(RPAREN)) return true;
8583 return false;
8584 }
8585
8586 private boolean jj_3R_140()
8587 {
8588 if (jj_3R_111()) return true;
8589 return false;
8590 }
8591
8592 private boolean jj_3R_176()
8593 {
8594 if (jj_scan_token(RETURN)) return true;
8595 Token xsp;
8596 xsp = jj_scanpos;
8597 if (jj_3_28()) jj_scanpos = xsp;
8598 return false;
8599 }
8600
8601 private boolean jj_3_23()
8602 {
8603 if (jj_3R_47()) return true;
8604 return false;
8605 }
8606
8607 private boolean jj_3R_179()
8608 {
8609 if (jj_scan_token(THROW)) return true;
8610 Token xsp;
8611 xsp = jj_scanpos;
8612 if (jj_3_29()) jj_scanpos = xsp;
8613 return false;
8614 }
8615
8616 private boolean jj_3_17()
8617 {
8618 if (jj_3R_51()) return true;
8619 return false;
8620 }
8621
8622 private boolean jj_3_28()
8623 {
8624 if (jj_3R_53()) return true;
8625 return false;
8626 }
8627
8628 private boolean jj_3R_177()
8629 {
8630 if (jj_scan_token(CONTINUE)) return true;
8631 return false;
8632 }
8633
8634 private boolean jj_3_20()
8635 {
8636 if (jj_3R_47()) return true;
8637 return false;
8638 }
8639
8640 private boolean jj_3R_313()
8641 {
8642 if (jj_3R_51()) return true;
8643 return false;
8644 }
8645
8646 private boolean jj_3_29()
8647 {
8648 if (jj_3R_53()) return true;
8649 return false;
8650 }
8651
8652 private boolean jj_3R_178()
8653 {
8654 if (jj_scan_token(BREAK)) return true;
8655 return false;
8656 }
8657
8658 private boolean jj_3R_173()
8659 {
8660 if (jj_scan_token(FOR)) return true;
8661 if (jj_scan_token(LPAREN)) return true;
8662 Token xsp;
8663 xsp = jj_scanpos;
8664 if (jj_3_34()) {
8665 jj_scanpos = xsp;
8666 if (jj_3_35()) return true;
8667 }
8668 if (jj_scan_token(RPAREN)) return true;
8669 xsp = jj_scanpos;
8670 if (jj_3R_307()) {
8671 jj_scanpos = xsp;
8672 if (jj_3_36()) return true;
8673 }
8674 return false;
8675 }
8676
8677 private boolean jj_3R_268()
8678 {
8679 if (jj_3R_51()) return true;
8680 return false;
8681 }
8682
8683 private boolean jj_3_18()
8684 {
8685 if (jj_3R_41()) return true;
8686 return false;
8687 }
8688
8689 private boolean jj_3_34()
8690 {
8691 if (jj_3R_55()) return true;
8692 if (jj_scan_token(COLON)) return true;
8693 if (jj_3R_41()) return true;
8694 return false;
8695 }
8696
8697 private boolean jj_3_22()
8698 {
8699 if (jj_3R_47()) return true;
8700 return false;
8701 }
8702
8703 private boolean jj_3_35()
8704 {
8705 Token xsp;
8706 xsp = jj_scanpos;
8707 if (jj_3_31()) jj_scanpos = xsp;
8708 if (jj_scan_token(SEMICOL)) return true;
8709 xsp = jj_scanpos;
8710 if (jj_3_32()) jj_scanpos = xsp;
8711 if (jj_scan_token(SEMICOL)) return true;
8712 xsp = jj_scanpos;
8713 if (jj_3_33()) jj_scanpos = xsp;
8714 return false;
8715 }
8716
8717 private boolean jj_3_31()
8718 {
8719 Token xsp;
8720 xsp = jj_scanpos;
8721 if (jj_3R_54()) {
8722 jj_scanpos = xsp;
8723 if (jj_3_30()) return true;
8724 }
8725 return false;
8726 }
8727
8728 private boolean jj_3_32()
8729 {
8730 if (jj_3R_41()) return true;
8731 return false;
8732 }
8733
8734 private boolean jj_3R_54()
8735 {
8736 if (jj_3R_45()) return true;
8737 return false;
8738 }
8739
8740 private boolean jj_3_33()
8741 {
8742 if (jj_3R_41()) return true;
8743 return false;
8744 }
8745
8746 private boolean jj_3R_307()
8747 {
8748 if (jj_3R_51()) return true;
8749 return false;
8750 }
8751
8752 private boolean jj_3R_55()
8753 {
8754 Token xsp;
8755 xsp = jj_scanpos;
8756 if (jj_3R_141()) {
8757 jj_scanpos = xsp;
8758 if (jj_3R_142()) {
8759 jj_scanpos = xsp;
8760 if (jj_3R_143()) {
8761 jj_scanpos = xsp;
8762 if (jj_3R_144()) return true;
8763 }
8764 }
8765 }
8766 return false;
8767 }
8768
8769 private boolean jj_3R_141()
8770 {
8771 if (jj_scan_token(VAR)) return true;
8772 if (jj_3R_183()) return true;
8773 return false;
8774 }
8775
8776 private boolean jj_3_27()
8777 {
8778 if (jj_3R_47()) return true;
8779 return false;
8780 }
8781
8782 private boolean jj_3R_142()
8783 {
8784 if (jj_scan_token(LET)) return true;
8785 if (jj_3R_183()) return true;
8786 return false;
8787 }
8788
8789 private boolean jj_3R_143()
8790 {
8791 if (jj_scan_token(CONST)) return true;
8792 if (jj_3R_183()) return true;
8793 return false;
8794 }
8795
8796 private boolean jj_3R_144()
8797 {
8798 if (jj_3R_111()) return true;
8799 return false;
8800 }
8801
8802 private boolean jj_3_30()
8803 {
8804 if (jj_3R_41()) return true;
8805 return false;
8806 }
8807
8808 private boolean jj_3R_308()
8809 {
8810 if (jj_3R_51()) return true;
8811 return false;
8812 }
8813
8814 private boolean jj_3R_45()
8815 {
8816 Token xsp;
8817 xsp = jj_scanpos;
8818 if (jj_3R_118()) {
8819 jj_scanpos = xsp;
8820 if (jj_3R_119()) {
8821 jj_scanpos = xsp;
8822 if (jj_3R_120()) return true;
8823 }
8824 }
8825 return false;
8826 }
8827
8828 private boolean jj_3R_118()
8829 {
8830 if (jj_scan_token(VAR)) return true;
8831 if (jj_3R_166()) return true;
8832 Token xsp;
8833 while (true) {
8834 xsp = jj_scanpos;
8835 if (jj_3R_167()) { jj_scanpos = xsp; break; }
8836 }
8837 return false;
8838 }
8839
8840 private boolean jj_3R_119()
8841 {
8842 if (jj_scan_token(LET)) return true;
8843 if (jj_3R_168()) return true;
8844 Token xsp;
8845 while (true) {
8846 xsp = jj_scanpos;
8847 if (jj_3R_169()) { jj_scanpos = xsp; break; }
8848 }
8849 return false;
8850 }
8851
8852 private boolean jj_3R_120()
8853 {
8854 if (jj_scan_token(CONST)) return true;
8855 if (jj_3R_170()) return true;
8856 Token xsp;
8857 while (true) {
8858 xsp = jj_scanpos;
8859 if (jj_3R_304()) { jj_scanpos = xsp; break; }
8860 }
8861 return false;
8862 }
8863
8864 private boolean jj_3_36()
8865 {
8866 if (jj_3R_47()) return true;
8867 return false;
8868 }
8869
8870 private boolean jj_3R_166()
8871 {
8872 if (jj_3R_183()) return true;
8873 Token xsp;
8874 xsp = jj_scanpos;
8875 if (jj_3R_199()) jj_scanpos = xsp;
8876 return false;
8877 }
8878
8879 private boolean jj_3R_168()
8880 {
8881 if (jj_3R_183()) return true;
8882 Token xsp;
8883 xsp = jj_scanpos;
8884 if (jj_3R_200()) jj_scanpos = xsp;
8885 return false;
8886 }
8887
8888 private boolean jj_3R_170()
8889 {
8890 if (jj_3R_183()) return true;
8891 if (jj_scan_token(assign)) return true;
8892 if (jj_3R_41()) return true;
8893 return false;
8894 }
8895
8896 private boolean jj_3R_167()
8897 {
8898 if (jj_scan_token(COMMA)) return true;
8899 if (jj_3R_166()) return true;
8900 return false;
8901 }
8902
8903 private boolean jj_3_26()
8904 {
8905 if (jj_3R_47()) return true;
8906 return false;
8907 }
8908
8909 private boolean jj_3R_169()
8910 {
8911 if (jj_scan_token(COMMA)) return true;
8912 if (jj_3R_168()) return true;
8913 return false;
8914 }
8915
8916 private boolean jj_3R_183()
8917 {
8918 if (jj_scan_token(IDENTIFIER)) return true;
8919 return false;
8920 }
8921
8922 private boolean jj_3R_304()
8923 {
8924 if (jj_scan_token(COMMA)) return true;
8925 if (jj_3R_170()) return true;
8926 return false;
8927 }
8928
8929 private boolean jj_3R_121()
8930 {
8931 if (jj_scan_token(IDENTIFIER)) return true;
8932 return false;
8933 }
8934
8935 private boolean jj_3R_199()
8936 {
8937 if (jj_scan_token(assign)) return true;
8938 if (jj_3R_41()) return true;
8939 return false;
8940 }
8941
8942 private boolean jj_3R_200()
8943 {
8944 if (jj_scan_token(assign)) return true;
8945 if (jj_3R_41()) return true;
8946 return false;
8947 }
8948
8949 private boolean jj_3R_48()
8950 {
8951 if (jj_scan_token(SWITCH)) return true;
8952 if (jj_scan_token(LPAREN)) return true;
8953 if (jj_3R_41()) return true;
8954 if (jj_scan_token(RPAREN)) return true;
8955 if (jj_scan_token(LCURLY)) return true;
8956 Token xsp;
8957 xsp = jj_scanpos;
8958 if (jj_3R_311()) {
8959 jj_scanpos = xsp;
8960 if (jj_3R_312()) return true;
8961 }
8962 if (jj_scan_token(RCURLY)) return true;
8963 return false;
8964 }
8965
8966 private boolean jj_3R_311()
8967 {
8968 Token xsp;
8969 while (true) {
8970 xsp = jj_scanpos;
8971 if (jj_3R_315()) { jj_scanpos = xsp; break; }
8972 }
8973 return false;
8974 }
8975
8976 private boolean jj_3R_312()
8977 {
8978 Token xsp;
8979 while (true) {
8980 xsp = jj_scanpos;
8981 if (jj_3R_316()) { jj_scanpos = xsp; break; }
8982 }
8983 return false;
8984 }
8985
8986 private boolean jj_3R_56()
8987 {
8988 Token xsp;
8989 xsp = jj_scanpos;
8990 if (jj_3R_145()) {
8991 jj_scanpos = xsp;
8992 if (jj_3R_146()) return true;
8993 }
8994 return false;
8995 }
8996
8997 private boolean jj_3R_145()
8998 {
8999 if (jj_scan_token(CASE)) return true;
9000 if (jj_3R_57()) return true;
9001 if (jj_scan_token(COLON)) return true;
9002 return false;
9003 }
9004
9005 private boolean jj_3_37()
9006 {
9007 if (jj_3R_56()) return true;
9008 return false;
9009 }
9010
9011 private boolean jj_3R_317()
9012 {
9013 Token xsp;
9014 xsp = jj_scanpos;
9015 if (jj_3R_318()) {
9016 jj_scanpos = xsp;
9017 if (jj_3R_319()) return true;
9018 }
9019 xsp = jj_scanpos;
9020 if (jj_3_42()) jj_scanpos = xsp;
9021 return false;
9022 }
9023
9024 private boolean jj_3R_318()
9025 {
9026 Token xsp;
9027 if (jj_3_38()) return true;
9028 while (true) {
9029 xsp = jj_scanpos;
9030 if (jj_3_38()) { jj_scanpos = xsp; break; }
9031 }
9032 return false;
9033 }
9034
9035 private boolean jj_3_38()
9036 {
9037 if (jj_scan_token(CASE)) return true;
9038 if (jj_3R_57()) return true;
9039 if (jj_scan_token(COLON)) return true;
9040 return false;
9041 }
9042
9043 private boolean jj_3_42()
9044 {
9045 Token xsp;
9046 xsp = jj_scanpos;
9047 if (jj_3R_58()) {
9048 jj_scanpos = xsp;
9049 if (jj_3_41()) return true;
9050 }
9051 return false;
9052 }
9053
9054 private boolean jj_3R_58()
9055 {
9056 if (jj_3R_51()) return true;
9057 return false;
9058 }
9059
9060 private boolean jj_3R_319()
9061 {
9062 if (jj_scan_token(CASE_DEFAULT)) return true;
9063 if (jj_scan_token(COLON)) return true;
9064 return false;
9065 }
9066
9067 private boolean jj_3_40()
9068 {
9069 if (jj_scan_token(LCURLY)) return true;
9070 return false;
9071 }
9072
9073 private boolean jj_3R_229()
9074 {
9075 if (jj_scan_token(SWITCH)) return true;
9076 if (jj_scan_token(LPAREN)) return true;
9077 if (jj_3R_41()) return true;
9078 if (jj_scan_token(RPAREN)) return true;
9079 if (jj_scan_token(LCURLY)) return true;
9080 Token xsp;
9081 while (true) {
9082 xsp = jj_scanpos;
9083 if (jj_3R_281()) { jj_scanpos = xsp; break; }
9084 }
9085 if (jj_scan_token(RCURLY)) return true;
9086 return false;
9087 }
9088
9089 private boolean jj_3R_146()
9090 {
9091 if (jj_scan_token(CASE_DEFAULT)) return true;
9092 if (jj_scan_token(COLON)) return true;
9093 return false;
9094 }
9095
9096 private boolean jj_3R_281()
9097 {
9098 if (jj_3R_287()) return true;
9099 return false;
9100 }
9101
9102 private boolean jj_3R_315()
9103 {
9104 if (jj_3R_317()) return true;
9105 return false;
9106 }
9107
9108 private boolean jj_3R_287()
9109 {
9110 Token xsp;
9111 xsp = jj_scanpos;
9112 if (jj_3_43()) {
9113 jj_scanpos = xsp;
9114 if (jj_3R_293()) return true;
9115 }
9116 xsp = jj_scanpos;
9117 if (jj_3_44()) {
9118 jj_scanpos = xsp;
9119 if (jj_3_45()) return true;
9120 }
9121 return false;
9122 }
9123
9124 private boolean jj_3_43()
9125 {
9126 if (jj_scan_token(CASE)) return true;
9127 if (jj_3R_59()) return true;
9128 if (jj_scan_token(LAMBDA)) return true;
9129 return false;
9130 }
9131
9132 private boolean jj_3R_316()
9133 {
9134 if (jj_3R_287()) return true;
9135 return false;
9136 }
9137
9138 private boolean jj_3R_293()
9139 {
9140 if (jj_scan_token(CASE_DEFAULT)) return true;
9141 if (jj_scan_token(LAMBDA)) return true;
9142 return false;
9143 }
9144
9145 private boolean jj_3_41()
9146 {
9147 Token xsp;
9148 if (jj_3_39()) return true;
9149 while (true) {
9150 xsp = jj_scanpos;
9151 if (jj_3_39()) { jj_scanpos = xsp; break; }
9152 }
9153 return false;
9154 }
9155
9156 private boolean jj_3_44()
9157 {
9158 if (jj_3R_51()) return true;
9159 return false;
9160 }
9161
9162 private boolean jj_3_39()
9163 {
9164 if (jj_3R_47()) return true;
9165 return false;
9166 }
9167
9168 private boolean jj_3R_59()
9169 {
9170 if (jj_3R_57()) return true;
9171 Token xsp;
9172 while (true) {
9173 xsp = jj_scanpos;
9174 if (jj_3_46()) { jj_scanpos = xsp; break; }
9175 }
9176 return false;
9177 }
9178
9179 private boolean jj_3R_57()
9180 {
9181 Token xsp;
9182 xsp = jj_scanpos;
9183 if (jj_3_47()) {
9184 jj_scanpos = xsp;
9185 if (jj_3_48()) {
9186 jj_scanpos = xsp;
9187 if (jj_3R_147()) {
9188 jj_scanpos = xsp;
9189 if (jj_3R_148()) {
9190 jj_scanpos = xsp;
9191 if (jj_3R_149()) {
9192 jj_scanpos = xsp;
9193 if (jj_3R_150()) {
9194 jj_scanpos = xsp;
9195 if (jj_3R_151()) {
9196 jj_scanpos = xsp;
9197 if (jj_3R_152()) return true;
9198 }
9199 }
9200 }
9201 }
9202 }
9203 }
9204 }
9205 return false;
9206 }
9207
9208 private boolean jj_3_47()
9209 {
9210 Token xsp;
9211 xsp = jj_scanpos;
9212 if (jj_3R_60()) jj_scanpos = xsp;
9213 if (jj_scan_token(INTEGER_LITERAL)) return true;
9214 return false;
9215 }
9216
9217 private boolean jj_3_48()
9218 {
9219 Token xsp;
9220 xsp = jj_scanpos;
9221 if (jj_3R_61()) jj_scanpos = xsp;
9222 if (jj_scan_token(FLOAT_LITERAL)) return true;
9223 return false;
9224 }
9225
9226 private boolean jj_3_45()
9227 {
9228 if (jj_3R_41()) return true;
9229 Token xsp;
9230 xsp = jj_scanpos;
9231 if (jj_scan_token(21)) jj_scanpos = xsp;
9232 return false;
9233 }
9234
9235 private boolean jj_3R_147()
9236 {
9237 if (jj_scan_token(STRING_LITERAL)) return true;
9238 return false;
9239 }
9240
9241 private boolean jj_3R_148()
9242 {
9243 if (jj_scan_token(TRUE)) return true;
9244 return false;
9245 }
9246
9247 private boolean jj_3R_149()
9248 {
9249 if (jj_scan_token(FALSE)) return true;
9250 return false;
9251 }
9252
9253 private boolean jj_3R_150()
9254 {
9255 if (jj_scan_token(NULL)) return true;
9256 return false;
9257 }
9258
9259 private boolean jj_3R_151()
9260 {
9261 if (jj_scan_token(NAN_LITERAL)) return true;
9262 return false;
9263 }
9264
9265 private boolean jj_3R_152()
9266 {
9267 if (jj_3R_184()) return true;
9268 return false;
9269 }
9270
9271 private boolean jj_3R_60()
9272 {
9273 Token xsp;
9274 xsp = jj_scanpos;
9275 if (jj_scan_token(67)) {
9276 jj_scanpos = xsp;
9277 if (jj_scan_token(69)) return true;
9278 }
9279 return false;
9280 }
9281
9282 private boolean jj_3R_61()
9283 {
9284 Token xsp;
9285 xsp = jj_scanpos;
9286 if (jj_scan_token(67)) {
9287 jj_scanpos = xsp;
9288 if (jj_scan_token(69)) return true;
9289 }
9290 return false;
9291 }
9292
9293 private boolean jj_3R_116()
9294 {
9295 if (jj_scan_token(PRAGMA)) return true;
9296 if (jj_3R_184()) return true;
9297 if (jj_3R_297()) return true;
9298 return false;
9299 }
9300
9301 private boolean jj_3R_184()
9302 {
9303 Token xsp;
9304 xsp = jj_scanpos;
9305 if (jj_3R_205()) {
9306 jj_scanpos = xsp;
9307 if (jj_3R_206()) return true;
9308 }
9309 return false;
9310 }
9311
9312 private boolean jj_3R_205()
9313 {
9314 if (jj_scan_token(IDENTIFIER)) return true;
9315 Token xsp;
9316 while (true) {
9317 xsp = jj_scanpos;
9318 if (jj_3R_255()) { jj_scanpos = xsp; break; }
9319 }
9320 return false;
9321 }
9322
9323 private boolean jj_3_46()
9324 {
9325 if (jj_scan_token(COMMA)) return true;
9326 if (jj_3R_57()) return true;
9327 return false;
9328 }
9329
9330 private boolean jj_3R_206()
9331 {
9332 if (jj_scan_token(DOT)) return true;
9333 if (jj_scan_token(DOT_IDENTIFIER)) return true;
9334 return false;
9335 }
9336
9337 private boolean jj_3R_297()
9338 {
9339 Token xsp;
9340 xsp = jj_scanpos;
9341 if (jj_3_50()) {
9342 jj_scanpos = xsp;
9343 if (jj_3_51()) {
9344 jj_scanpos = xsp;
9345 if (jj_3R_298()) {
9346 jj_scanpos = xsp;
9347 if (jj_3R_299()) {
9348 jj_scanpos = xsp;
9349 if (jj_3R_300()) {
9350 jj_scanpos = xsp;
9351 if (jj_3R_301()) {
9352 jj_scanpos = xsp;
9353 if (jj_3R_302()) {
9354 jj_scanpos = xsp;
9355 if (jj_3R_303()) return true;
9356 }
9357 }
9358 }
9359 }
9360 }
9361 }
9362 }
9363 return false;
9364 }
9365
9366 private boolean jj_3_50()
9367 {
9368 Token xsp;
9369 xsp = jj_scanpos;
9370 if (jj_3R_62()) jj_scanpos = xsp;
9371 if (jj_scan_token(INTEGER_LITERAL)) return true;
9372 return false;
9373 }
9374
9375 private boolean jj_3_51()
9376 {
9377 Token xsp;
9378 xsp = jj_scanpos;
9379 if (jj_3R_63()) jj_scanpos = xsp;
9380 if (jj_scan_token(FLOAT_LITERAL)) return true;
9381 return false;
9382 }
9383
9384 private boolean jj_3R_298()
9385 {
9386 if (jj_scan_token(STRING_LITERAL)) return true;
9387 return false;
9388 }
9389
9390 private boolean jj_3R_299()
9391 {
9392 if (jj_3R_184()) return true;
9393 return false;
9394 }
9395
9396 private boolean jj_3R_300()
9397 {
9398 if (jj_scan_token(TRUE)) return true;
9399 return false;
9400 }
9401
9402 private boolean jj_3R_301()
9403 {
9404 if (jj_scan_token(FALSE)) return true;
9405 return false;
9406 }
9407
9408 private boolean jj_3R_302()
9409 {
9410 if (jj_scan_token(NULL)) return true;
9411 return false;
9412 }
9413
9414 private boolean jj_3R_303()
9415 {
9416 if (jj_scan_token(NAN_LITERAL)) return true;
9417 return false;
9418 }
9419
9420 private boolean jj_3R_62()
9421 {
9422 Token xsp;
9423 xsp = jj_scanpos;
9424 if (jj_scan_token(67)) {
9425 jj_scanpos = xsp;
9426 if (jj_scan_token(69)) return true;
9427 }
9428 return false;
9429 }
9430
9431 private boolean jj_3R_63()
9432 {
9433 Token xsp;
9434 xsp = jj_scanpos;
9435 if (jj_scan_token(67)) {
9436 jj_scanpos = xsp;
9437 if (jj_scan_token(69)) return true;
9438 }
9439 return false;
9440 }
9441
9442 private boolean jj_3R_41()
9443 {
9444 if (jj_3R_117()) return true;
9445 return false;
9446 }
9447
9448 private boolean jj_3R_117()
9449 {
9450 if (jj_3R_165()) return true;
9451 Token xsp;
9452 xsp = jj_scanpos;
9453 if (jj_3_52()) jj_scanpos = xsp;
9454 return false;
9455 }
9456
9457 private boolean jj_3_52()
9458 {
9459 Token xsp;
9460 xsp = jj_scanpos;
9461 if (jj_3R_64()) {
9462 jj_scanpos = xsp;
9463 if (jj_3R_65()) {
9464 jj_scanpos = xsp;
9465 if (jj_3R_66()) {
9466 jj_scanpos = xsp;
9467 if (jj_3R_67()) {
9468 jj_scanpos = xsp;
9469 if (jj_3R_68()) {
9470 jj_scanpos = xsp;
9471 if (jj_3R_69()) {
9472 jj_scanpos = xsp;
9473 if (jj_3R_70()) {
9474 jj_scanpos = xsp;
9475 if (jj_3R_71()) {
9476 jj_scanpos = xsp;
9477 if (jj_3R_72()) {
9478 jj_scanpos = xsp;
9479 if (jj_3R_73()) {
9480 jj_scanpos = xsp;
9481 if (jj_3R_74()) {
9482 jj_scanpos = xsp;
9483 if (jj_3R_75()) return true;
9484 }
9485 }
9486 }
9487 }
9488 }
9489 }
9490 }
9491 }
9492 }
9493 }
9494 }
9495 return false;
9496 }
9497
9498 private boolean jj_3R_255()
9499 {
9500 if (jj_3R_184()) return true;
9501 return false;
9502 }
9503
9504 private boolean jj_3R_64()
9505 {
9506 if (jj_scan_token(plus_assign)) return true;
9507 if (jj_3R_41()) return true;
9508 return false;
9509 }
9510
9511 private boolean jj_3R_65()
9512 {
9513 if (jj_scan_token(mult_assign)) return true;
9514 if (jj_3R_41()) return true;
9515 return false;
9516 }
9517
9518 private boolean jj_3R_66()
9519 {
9520 if (jj_scan_token(div_assign)) return true;
9521 if (jj_3R_41()) return true;
9522 return false;
9523 }
9524
9525 private boolean jj_3R_67()
9526 {
9527 if (jj_scan_token(mod_assign)) return true;
9528 if (jj_3R_41()) return true;
9529 return false;
9530 }
9531
9532 private boolean jj_3R_68()
9533 {
9534 if (jj_scan_token(and_assign)) return true;
9535 if (jj_3R_41()) return true;
9536 return false;
9537 }
9538
9539 private boolean jj_3_49()
9540 {
9541 if (jj_scan_token(DOT)) return true;
9542 return false;
9543 }
9544
9545 private boolean jj_3R_69()
9546 {
9547 if (jj_scan_token(or_assign)) return true;
9548 if (jj_3R_41()) return true;
9549 return false;
9550 }
9551
9552 private boolean jj_3R_70()
9553 {
9554 if (jj_scan_token(xor_assign)) return true;
9555 if (jj_3R_41()) return true;
9556 return false;
9557 }
9558
9559 private boolean jj_3R_71()
9560 {
9561 if (jj_scan_token(minus_assign)) return true;
9562 if (jj_3R_41()) return true;
9563 return false;
9564 }
9565
9566 private boolean jj_3R_72()
9567 {
9568 if (jj_scan_token(lshift_assign)) return true;
9569 if (jj_3R_41()) return true;
9570 return false;
9571 }
9572
9573 private boolean jj_3R_73()
9574 {
9575 if (jj_scan_token(rshift_assign)) return true;
9576 if (jj_3R_41()) return true;
9577 return false;
9578 }
9579
9580 private boolean jj_3R_74()
9581 {
9582 if (jj_scan_token(rshiftu_assign)) return true;
9583 if (jj_3R_41()) return true;
9584 return false;
9585 }
9586
9587 private boolean jj_3R_75()
9588 {
9589 if (jj_scan_token(assign)) return true;
9590 if (jj_3R_41()) return true;
9591 return false;
9592 }
9593
9594 private boolean jj_3R_165()
9595 {
9596 if (jj_3R_198()) return true;
9597 Token xsp;
9598 xsp = jj_scanpos;
9599 if (jj_3_53()) jj_scanpos = xsp;
9600 return false;
9601 }
9602
9603 private boolean jj_3_53()
9604 {
9605 Token xsp;
9606 xsp = jj_scanpos;
9607 if (jj_3R_76()) {
9608 jj_scanpos = xsp;
9609 if (jj_3R_77()) {
9610 jj_scanpos = xsp;
9611 if (jj_3R_78()) return true;
9612 }
9613 }
9614 return false;
9615 }
9616
9617 private boolean jj_3R_76()
9618 {
9619 if (jj_scan_token(QMARK)) return true;
9620 if (jj_3R_41()) return true;
9621 if (jj_scan_token(COLON)) return true;
9622 if (jj_3R_41()) return true;
9623 return false;
9624 }
9625
9626 private boolean jj_3R_77()
9627 {
9628 if (jj_scan_token(ELVIS)) return true;
9629 if (jj_3R_41()) return true;
9630 return false;
9631 }
9632
9633 private boolean jj_3R_78()
9634 {
9635 if (jj_scan_token(NULLP)) return true;
9636 if (jj_3R_41()) return true;
9637 return false;
9638 }
9639
9640 private boolean jj_3R_198()
9641 {
9642 if (jj_3R_79()) return true;
9643 Token xsp;
9644 while (true) {
9645 xsp = jj_scanpos;
9646 if (jj_3_54()) { jj_scanpos = xsp; break; }
9647 }
9648 return false;
9649 }
9650
9651 private boolean jj_3_54()
9652 {
9653 Token xsp;
9654 xsp = jj_scanpos;
9655 if (jj_scan_token(31)) {
9656 jj_scanpos = xsp;
9657 if (jj_scan_token(34)) return true;
9658 }
9659 if (jj_3R_79()) return true;
9660 return false;
9661 }
9662
9663 private boolean jj_3R_79()
9664 {
9665 if (jj_3R_80()) return true;
9666 Token xsp;
9667 while (true) {
9668 xsp = jj_scanpos;
9669 if (jj_3_55()) { jj_scanpos = xsp; break; }
9670 }
9671 return false;
9672 }
9673
9674 private boolean jj_3_55()
9675 {
9676 Token xsp;
9677 xsp = jj_scanpos;
9678 if (jj_scan_token(30)) {
9679 jj_scanpos = xsp;
9680 if (jj_scan_token(33)) return true;
9681 }
9682 if (jj_3R_80()) return true;
9683 return false;
9684 }
9685
9686 private boolean jj_3R_80()
9687 {
9688 if (jj_3R_81()) return true;
9689 Token xsp;
9690 while (true) {
9691 xsp = jj_scanpos;
9692 if (jj_3_56()) { jj_scanpos = xsp; break; }
9693 }
9694 return false;
9695 }
9696
9697 private boolean jj_3_56()
9698 {
9699 if (jj_scan_token(or)) return true;
9700 if (jj_3R_81()) return true;
9701 return false;
9702 }
9703
9704 private boolean jj_3R_81()
9705 {
9706 if (jj_3R_82()) return true;
9707 Token xsp;
9708 while (true) {
9709 xsp = jj_scanpos;
9710 if (jj_3_57()) { jj_scanpos = xsp; break; }
9711 }
9712 return false;
9713 }
9714
9715 private boolean jj_3_57()
9716 {
9717 if (jj_scan_token(xor)) return true;
9718 if (jj_3R_82()) return true;
9719 return false;
9720 }
9721
9722 private boolean jj_3R_82()
9723 {
9724 if (jj_3R_83()) return true;
9725 Token xsp;
9726 while (true) {
9727 xsp = jj_scanpos;
9728 if (jj_3_58()) { jj_scanpos = xsp; break; }
9729 }
9730 return false;
9731 }
9732
9733 private boolean jj_3_58()
9734 {
9735 if (jj_scan_token(and)) return true;
9736 if (jj_3R_83()) return true;
9737 return false;
9738 }
9739
9740 private boolean jj_3R_83()
9741 {
9742 if (jj_3R_153()) return true;
9743 Token xsp;
9744 xsp = jj_scanpos;
9745 if (jj_3_59()) jj_scanpos = xsp;
9746 return false;
9747 }
9748
9749 private boolean jj_3_59()
9750 {
9751 Token xsp;
9752 xsp = jj_scanpos;
9753 if (jj_3R_84()) {
9754 jj_scanpos = xsp;
9755 if (jj_3R_85()) {
9756 jj_scanpos = xsp;
9757 if (jj_3R_86()) {
9758 jj_scanpos = xsp;
9759 if (jj_3R_87()) {
9760 jj_scanpos = xsp;
9761 if (jj_3R_88()) return true;
9762 }
9763 }
9764 }
9765 }
9766 return false;
9767 }
9768
9769 private boolean jj_3R_84()
9770 {
9771 Token xsp;
9772 xsp = jj_scanpos;
9773 if (jj_scan_token(35)) {
9774 jj_scanpos = xsp;
9775 if (jj_scan_token(49)) return true;
9776 }
9777 if (jj_3R_153()) return true;
9778 return false;
9779 }
9780
9781 private boolean jj_3R_85()
9782 {
9783 Token xsp;
9784 xsp = jj_scanpos;
9785 if (jj_scan_token(36)) {
9786 jj_scanpos = xsp;
9787 if (jj_scan_token(50)) return true;
9788 }
9789 if (jj_3R_153()) return true;
9790 return false;
9791 }
9792
9793 private boolean jj_3R_86()
9794 {
9795 if (jj_scan_token(eqstrict)) return true;
9796 if (jj_3R_153()) return true;
9797 return false;
9798 }
9799
9800 private boolean jj_3R_87()
9801 {
9802 if (jj_scan_token(neqstrict)) return true;
9803 if (jj_3R_153()) return true;
9804 return false;
9805 }
9806
9807 private boolean jj_3R_88()
9808 {
9809 if (jj_scan_token(range)) return true;
9810 if (jj_3R_153()) return true;
9811 return false;
9812 }
9813
9814 private boolean jj_3R_153()
9815 {
9816 if (jj_3R_154()) return true;
9817 Token xsp;
9818 xsp = jj_scanpos;
9819 if (jj_3_60()) jj_scanpos = xsp;
9820 return false;
9821 }
9822
9823 private boolean jj_3_60()
9824 {
9825 Token xsp;
9826 xsp = jj_scanpos;
9827 if (jj_3R_89()) {
9828 jj_scanpos = xsp;
9829 if (jj_3R_90()) {
9830 jj_scanpos = xsp;
9831 if (jj_3R_91()) {
9832 jj_scanpos = xsp;
9833 if (jj_3R_92()) {
9834 jj_scanpos = xsp;
9835 if (jj_3R_93()) {
9836 jj_scanpos = xsp;
9837 if (jj_3R_94()) {
9838 jj_scanpos = xsp;
9839 if (jj_3R_95()) {
9840 jj_scanpos = xsp;
9841 if (jj_3R_96()) {
9842 jj_scanpos = xsp;
9843 if (jj_3R_97()) {
9844 jj_scanpos = xsp;
9845 if (jj_3R_98()) {
9846 jj_scanpos = xsp;
9847 if (jj_3R_99()) {
9848 jj_scanpos = xsp;
9849 if (jj_3R_100()) return true;
9850 }
9851 }
9852 }
9853 }
9854 }
9855 }
9856 }
9857 }
9858 }
9859 }
9860 }
9861 return false;
9862 }
9863
9864 private boolean jj_3R_89()
9865 {
9866 Token xsp;
9867 xsp = jj_scanpos;
9868 if (jj_scan_token(39)) {
9869 jj_scanpos = xsp;
9870 if (jj_scan_token(53)) return true;
9871 }
9872 if (jj_3R_154()) return true;
9873 return false;
9874 }
9875
9876 private boolean jj_3R_90()
9877 {
9878 Token xsp;
9879 xsp = jj_scanpos;
9880 if (jj_scan_token(37)) {
9881 jj_scanpos = xsp;
9882 if (jj_scan_token(51)) return true;
9883 }
9884 if (jj_3R_154()) return true;
9885 return false;
9886 }
9887
9888 private boolean jj_3R_91()
9889 {
9890 Token xsp;
9891 xsp = jj_scanpos;
9892 if (jj_scan_token(40)) {
9893 jj_scanpos = xsp;
9894 if (jj_scan_token(54)) return true;
9895 }
9896 if (jj_3R_154()) return true;
9897 return false;
9898 }
9899
9900 private boolean jj_3R_92()
9901 {
9902 Token xsp;
9903 xsp = jj_scanpos;
9904 if (jj_scan_token(38)) {
9905 jj_scanpos = xsp;
9906 if (jj_scan_token(52)) return true;
9907 }
9908 if (jj_3R_154()) return true;
9909 return false;
9910 }
9911
9912 private boolean jj_3R_93()
9913 {
9914 if (jj_scan_token(req)) return true;
9915 if (jj_3R_154()) return true;
9916 return false;
9917 }
9918
9919 private boolean jj_3R_94()
9920 {
9921 if (jj_scan_token(rne)) return true;
9922 if (jj_3R_154()) return true;
9923 return false;
9924 }
9925
9926 private boolean jj_3R_95()
9927 {
9928 if (jj_scan_token(seq)) return true;
9929 if (jj_3R_154()) return true;
9930 return false;
9931 }
9932
9933 private boolean jj_3R_96()
9934 {
9935 if (jj_scan_token(sne)) return true;
9936 if (jj_3R_154()) return true;
9937 return false;
9938 }
9939
9940 private boolean jj_3R_97()
9941 {
9942 if (jj_scan_token(eeq)) return true;
9943 if (jj_3R_154()) return true;
9944 return false;
9945 }
9946
9947 private boolean jj_3R_98()
9948 {
9949 if (jj_scan_token(ene)) return true;
9950 if (jj_3R_154()) return true;
9951 return false;
9952 }
9953
9954 private boolean jj_3R_99()
9955 {
9956 if (jj_scan_token(ISA)) return true;
9957 if (jj_3R_154()) return true;
9958 return false;
9959 }
9960
9961 private boolean jj_3R_100()
9962 {
9963 if (jj_scan_token(NISA)) return true;
9964 if (jj_3R_154()) return true;
9965 return false;
9966 }
9967
9968 private boolean jj_3R_154()
9969 {
9970 if (jj_3R_155()) return true;
9971 Token xsp;
9972 while (true) {
9973 xsp = jj_scanpos;
9974 if (jj_3_61()) { jj_scanpos = xsp; break; }
9975 }
9976 return false;
9977 }
9978
9979 private boolean jj_3_61()
9980 {
9981 Token xsp;
9982 xsp = jj_scanpos;
9983 if (jj_3R_101()) {
9984 jj_scanpos = xsp;
9985 if (jj_3R_102()) {
9986 jj_scanpos = xsp;
9987 if (jj_3R_103()) return true;
9988 }
9989 }
9990 return false;
9991 }
9992
9993 private boolean jj_3R_101()
9994 {
9995 if (jj_scan_token(lshift)) return true;
9996 if (jj_3R_155()) return true;
9997 return false;
9998 }
9999
10000 private boolean jj_3R_102()
10001 {
10002 if (jj_scan_token(rshift)) return true;
10003 if (jj_3R_155()) return true;
10004 return false;
10005 }
10006
10007 private boolean jj_3R_103()
10008 {
10009 if (jj_scan_token(rshiftu)) return true;
10010 if (jj_3R_155()) return true;
10011 return false;
10012 }
10013
10014 private boolean jj_3R_155()
10015 {
10016 if (jj_3R_156()) return true;
10017 Token xsp;
10018 while (true) {
10019 xsp = jj_scanpos;
10020 if (jj_3_62()) { jj_scanpos = xsp; break; }
10021 }
10022 return false;
10023 }
10024
10025 private boolean jj_3_62()
10026 {
10027 Token xsp;
10028 xsp = jj_scanpos;
10029 if (jj_3R_104()) {
10030 jj_scanpos = xsp;
10031 if (jj_3R_105()) return true;
10032 }
10033 return false;
10034 }
10035
10036 private boolean jj_3R_104()
10037 {
10038 if (jj_scan_token(plus)) return true;
10039 if (jj_3R_156()) return true;
10040 return false;
10041 }
10042
10043 private boolean jj_3R_105()
10044 {
10045 if (jj_scan_token(minus)) return true;
10046 if (jj_3R_156()) return true;
10047 return false;
10048 }
10049
10050 private boolean jj_3R_156()
10051 {
10052 if (jj_3R_157()) return true;
10053 Token xsp;
10054 while (true) {
10055 xsp = jj_scanpos;
10056 if (jj_3_63()) { jj_scanpos = xsp; break; }
10057 }
10058 return false;
10059 }
10060
10061 private boolean jj_3_63()
10062 {
10063 Token xsp;
10064 xsp = jj_scanpos;
10065 if (jj_3R_106()) {
10066 jj_scanpos = xsp;
10067 if (jj_3R_107()) {
10068 jj_scanpos = xsp;
10069 if (jj_3R_108()) return true;
10070 }
10071 }
10072 return false;
10073 }
10074
10075 private boolean jj_3R_106()
10076 {
10077 if (jj_scan_token(mult)) return true;
10078 if (jj_3R_157()) return true;
10079 return false;
10080 }
10081
10082 private boolean jj_3R_107()
10083 {
10084 Token xsp;
10085 xsp = jj_scanpos;
10086 if (jj_scan_token(72)) {
10087 jj_scanpos = xsp;
10088 if (jj_scan_token(84)) return true;
10089 }
10090 if (jj_3R_157()) return true;
10091 return false;
10092 }
10093
10094 private boolean jj_3R_108()
10095 {
10096 Token xsp;
10097 xsp = jj_scanpos;
10098 if (jj_scan_token(73)) {
10099 jj_scanpos = xsp;
10100 if (jj_scan_token(85)) return true;
10101 }
10102 if (jj_3R_157()) return true;
10103 return false;
10104 }
10105
10106 private boolean jj_3R_157()
10107 {
10108 Token xsp;
10109 xsp = jj_scanpos;
10110 if (jj_3R_185()) {
10111 jj_scanpos = xsp;
10112 if (jj_3R_186()) {
10113 jj_scanpos = xsp;
10114 if (jj_3R_187()) {
10115 jj_scanpos = xsp;
10116 if (jj_3R_188()) {
10117 jj_scanpos = xsp;
10118 if (jj_3R_189()) {
10119 jj_scanpos = xsp;
10120 if (jj_3R_190()) {
10121 jj_scanpos = xsp;
10122 if (jj_3R_191()) {
10123 jj_scanpos = xsp;
10124 if (jj_3R_192()) {
10125 jj_scanpos = xsp;
10126 if (jj_3_64()) return true;
10127 }
10128 }
10129 }
10130 }
10131 }
10132 }
10133 }
10134 }
10135 return false;
10136 }
10137
10138 private boolean jj_3R_185()
10139 {
10140 if (jj_scan_token(minus)) return true;
10141 if (jj_3R_157()) return true;
10142 return false;
10143 }
10144
10145 private boolean jj_3R_186()
10146 {
10147 if (jj_scan_token(plus)) return true;
10148 if (jj_3R_157()) return true;
10149 return false;
10150 }
10151
10152 private boolean jj_3R_187()
10153 {
10154 if (jj_scan_token(tilda)) return true;
10155 if (jj_3R_157()) return true;
10156 return false;
10157 }
10158
10159 private boolean jj_3R_188()
10160 {
10161 Token xsp;
10162 xsp = jj_scanpos;
10163 if (jj_scan_token(74)) {
10164 jj_scanpos = xsp;
10165 if (jj_scan_token(83)) return true;
10166 }
10167 if (jj_3R_157()) return true;
10168 return false;
10169 }
10170
10171 private boolean jj_3R_189()
10172 {
10173 if (jj_scan_token(EMPTY)) return true;
10174 if (jj_3R_157()) return true;
10175 return false;
10176 }
10177
10178 private boolean jj_3R_190()
10179 {
10180 if (jj_scan_token(SIZE)) return true;
10181 if (jj_3R_157()) return true;
10182 return false;
10183 }
10184
10185 private boolean jj_3R_191()
10186 {
10187 if (jj_scan_token(minusminus)) return true;
10188 if (jj_3R_157()) return true;
10189 return false;
10190 }
10191
10192 private boolean jj_3R_192()
10193 {
10194 if (jj_scan_token(plusplus)) return true;
10195 if (jj_3R_157()) return true;
10196 return false;
10197 }
10198
10199 private boolean jj_3_64()
10200 {
10201 if (jj_3R_109()) return true;
10202 return false;
10203 }
10204
10205 private boolean jj_3R_275()
10206 {
10207 Token xsp;
10208 xsp = jj_scanpos;
10209 if (jj_3R_276()) {
10210 jj_scanpos = xsp;
10211 if (jj_3R_277()) return true;
10212 }
10213 return false;
10214 }
10215
10216 private boolean jj_3R_276()
10217 {
10218 if (jj_scan_token(plusplus)) return true;
10219 return false;
10220 }
10221
10222 private boolean jj_3R_277()
10223 {
10224 if (jj_scan_token(minusminus)) return true;
10225 return false;
10226 }
10227
10228 private boolean jj_3R_109()
10229 {
10230 if (jj_3R_158()) return true;
10231 Token xsp;
10232 xsp = jj_scanpos;
10233 if (jj_3R_274()) jj_scanpos = xsp;
10234 return false;
10235 }
10236
10237 private boolean jj_3R_111()
10238 {
10239 Token xsp;
10240 xsp = jj_scanpos;
10241 if (jj_3R_159()) {
10242 jj_scanpos = xsp;
10243 if (jj_3R_160()) return true;
10244 }
10245 return false;
10246 }
10247
10248 private boolean jj_3R_159()
10249 {
10250 if (jj_scan_token(IDENTIFIER)) return true;
10251 return false;
10252 }
10253
10254 private boolean jj_3R_160()
10255 {
10256 if (jj_scan_token(REGISTER)) return true;
10257 return false;
10258 }
10259
10260 private boolean jj_3R_274()
10261 {
10262 if (jj_3R_275()) return true;
10263 return false;
10264 }
10265
10266 private boolean jj_3R_256()
10267 {
10268 if (jj_scan_token(IDENTIFIER)) return true;
10269 if (jj_scan_token(COLON)) return true;
10270 if (jj_scan_token(IDENTIFIER)) return true;
10271 return false;
10272 }
10273
10274 private boolean jj_3R_231()
10275 {
10276 Token xsp;
10277 xsp = jj_scanpos;
10278 if (jj_3R_241()) {
10279 jj_scanpos = xsp;
10280 if (jj_3R_242()) {
10281 jj_scanpos = xsp;
10282 if (jj_3R_243()) {
10283 jj_scanpos = xsp;
10284 if (jj_3R_244()) {
10285 jj_scanpos = xsp;
10286 if (jj_3R_245()) {
10287 jj_scanpos = xsp;
10288 if (jj_3R_246()) {
10289 jj_scanpos = xsp;
10290 if (jj_3R_247()) {
10291 jj_scanpos = xsp;
10292 if (jj_3R_248()) return true;
10293 }
10294 }
10295 }
10296 }
10297 }
10298 }
10299 }
10300 return false;
10301 }
10302
10303 private boolean jj_3R_241()
10304 {
10305 if (jj_3R_257()) return true;
10306 return false;
10307 }
10308
10309 private boolean jj_3R_242()
10310 {
10311 if (jj_3R_258()) return true;
10312 return false;
10313 }
10314
10315 private boolean jj_3R_243()
10316 {
10317 if (jj_3R_259()) return true;
10318 return false;
10319 }
10320
10321 private boolean jj_3R_244()
10322 {
10323 if (jj_3R_260()) return true;
10324 return false;
10325 }
10326
10327 private boolean jj_3R_245()
10328 {
10329 if (jj_3R_261()) return true;
10330 return false;
10331 }
10332
10333 private boolean jj_3R_246()
10334 {
10335 if (jj_3R_262()) return true;
10336 return false;
10337 }
10338
10339 private boolean jj_3R_247()
10340 {
10341 if (jj_3R_263()) return true;
10342 return false;
10343 }
10344
10345 private boolean jj_3R_248()
10346 {
10347 if (jj_3R_264()) return true;
10348 return false;
10349 }
10350
10351 private boolean jj_3R_264()
10352 {
10353 if (jj_scan_token(NAN_LITERAL)) return true;
10354 return false;
10355 }
10356
10357
10358 public ParserTokenManager token_source;
10359 SimpleCharStream jj_input_stream;
10360
10361 public Token token;
10362
10363 public Token jj_nt;
10364 private Token jj_scanpos, jj_lastpos;
10365 private int jj_la;
10366
10367 private boolean jj_lookingAhead = false;
10368 private boolean jj_semLA;
10369
10370
10371
10372
10373
10374 public Parser(final Provider stream) {
10375 jj_input_stream = new SimpleCharStream(stream, 1, 1);
10376 token_source = new ParserTokenManager(jj_input_stream);
10377 token = new Token();
10378 token.next = jj_nt = token_source.getNextToken();
10379 }
10380
10381
10382
10383
10384
10385 public Parser(final String sDSL) {
10386 this(new StringProvider(sDSL));
10387 }
10388
10389
10390
10391
10392
10393 public void ReInit(final String sDSL) {
10394 ReInit(new StringProvider(sDSL));
10395 }
10396
10397
10398
10399
10400 public void ReInit(final Provider stream) {
10401 if (jj_input_stream == null) {
10402 jj_input_stream = new SimpleCharStream(stream, 1, 1);
10403 } else {
10404 jj_input_stream.reInit(stream, 1, 1);
10405 }
10406 if (token_source == null) {
10407 token_source = new ParserTokenManager(jj_input_stream);
10408 }
10409
10410 token_source.ReInit(jj_input_stream);
10411 token = new Token();
10412 token.next = jj_nt = token_source.getNextToken();
10413 }
10414
10415
10416
10417
10418
10419 public Parser(final ParserTokenManager tm) {
10420 token_source = tm;
10421 token = new Token();
10422 token.next = jj_nt = token_source.getNextToken();
10423 }
10424
10425
10426
10427
10428
10429 public void ReInit(final ParserTokenManager tm) {
10430 token_source = tm;
10431 token = new Token();
10432 token.next = jj_nt = token_source.getNextToken();
10433 }
10434
10435 private Token jj_consume_token(final int kind) throws ParseException {
10436 final Token oldToken = token;
10437 token = jj_nt;
10438 if (token.next != null)
10439 jj_nt = jj_nt.next;
10440 else {
10441 jj_nt.next = token_source.getNextToken();
10442 jj_nt = jj_nt.next;
10443 }
10444 if (token.kind == kind) {
10445 return token;
10446 }
10447 jj_nt = token;
10448 token = oldToken;
10449 throw generateParseException();
10450 }
10451
10452 private static final class LookaheadSuccess extends IllegalStateException {}
10453 private static final LookaheadSuccess jj_ls = new LookaheadSuccess();
10454 private boolean jj_scan_token(int kind) {
10455 if (jj_scanpos == jj_lastpos) {
10456 jj_la--;
10457 if (jj_scanpos.next == null) {
10458 jj_lastpos = jj_scanpos = jj_scanpos.next = token_source.getNextToken();
10459 } else {
10460 jj_lastpos = jj_scanpos = jj_scanpos.next;
10461 }
10462 } else {
10463 jj_scanpos = jj_scanpos.next;
10464 }
10465 if (jj_scanpos.kind != kind) return true;
10466 if (jj_la == 0 && jj_scanpos == jj_lastpos) throw jj_ls;
10467 return false;
10468 }
10469
10470
10471
10472
10473
10474 public final Token getNextToken() {
10475 token = jj_nt;
10476 if (token.next != null)
10477 jj_nt = jj_nt.next;
10478 else
10479 jj_nt = jj_nt.next = token_source.getNextToken();
10480 return token;
10481 }
10482
10483
10484
10485
10486
10487 public final Token getToken(final int index) {
10488 Token t = jj_lookingAhead ? jj_scanpos : token;
10489 for (int i = 0; i < index; i++) {
10490 if (t.next == null)
10491 t.next = token_source.getNextToken();
10492 t = t.next;
10493 }
10494 return t;
10495 }
10496
10497
10498 public ParseException generateParseException() {
10499 final Token errortok = token.next;
10500 final int line = errortok.beginLine;
10501 final int column = errortok.beginColumn;
10502 final String mess = errortok.kind == 0 ? tokenImage[0] : errortok.image;
10503 return new ParseException("Parse error at line " + line + ", column " + column + ". Encountered: " + mess);
10504 }
10505
10506
10507
10508
10509 public final boolean trace_enabled() {
10510 return false;
10511 }
10512
10513
10514 public final void enable_tracing() {}
10515
10516
10517 public final void disable_tracing() {}
10518
10519 }