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