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