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