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