|
1
19
20
21 package org.netbeans.modules.debugger.jpda.expr;
22
23 class JavaParserimplements JavaParserTreeConstants, JavaParserConstants {
24 protected JJTJavaParserState jjtree = new JJTJavaParserState();
25 public static final String  LANGUAGE_JAVA_1_4 = "1.4.0";
26 public static final String LANGUAGE_JAVA_1_5 = "1.5.0";
27
28 private String target_jdk;
29 private boolean jdk1_5;
30 private boolean generics;
31
32 public void setTargetJDK(String target) {
33 target_jdk = target;
34 jdk1_5 = "1.5.0".compareTo(target_jdk) <= 0;
35 generics = "1.5.0".compareTo(target_jdk) <= 0;
36 }
37
38 private boolean expressionLookahead() {
39 Token tok = getToken(1);
40 if (tok.kind==COMMA) {
41 tok = getToken(2);
42 if (!(tok.kind==RPAREN || tok.kind==RBRACE)) {
43 return true;
44 }
45 }
46 return false;
47 }
48
49 private boolean castLookahead() {
50 int x = 0;
51 Token tok = getToken(++x);
52 if (tok.kind!=LPAREN) {
53 return false;
54 }
55 tok = getToken(++x);
56 if (tok.kind==IDENTIFIER) {
57 tok = getToken(++x);
58 while (true) {
59 if (tok.kind==LT) {
60 x = typeArguments(x);
61 if (x<0) {
62 return false;
63 }
64 tok = getToken(x); }
66 if (tok.kind==LBRACKET) {
67 while (tok.kind==LBRACKET) {
68 tok = getToken(++x);
69 if (tok.kind!=RBRACKET) {
70 return false;
71 }
72 tok = getToken(++x);
73 }
74 }
75 if (tok.kind==RPAREN) {
76 tok = getToken(++x);
77 return castEnd(tok);
78 } else if (tok.kind!=DOT) {
79 return false;
80 }
81 tok = getToken(++x);
82 if (isPrimitiveType(tok)) {
83 tok = getToken(++x);
84 if (tok.kind==LBRACKET) {
85 while (tok.kind==LBRACKET) {
86 tok = getToken(++x);
87 if (tok.kind!=RBRACKET) {
88 return false;
89 }
90 tok = getToken(++x);
91 }
92 }
93 return (tok.kind==RPAREN);
94 } else if (tok.kind==IDENTIFIER) {
95 tok = getToken(++x);
96 }
97
98 }
99 } else if (isPrimitiveType(tok)) {
100 tok = getToken(++x);
101 if (tok.kind==LBRACKET) {
102 while (tok.kind==LBRACKET) {
103 tok = getToken(++x);
104 if (tok.kind!=RBRACKET) {
105 return false;
106 }
107 tok = getToken(++x);
108 }
109 }
110 return (tok.kind==RPAREN);
111 }
112 return false;
113 }
114
115
116 private boolean isPrimitiveType(Token tok) {
117 return tok.kind==BOOLEAN || tok.kind==CHAR || tok.kind==BYTE
118 || tok.kind==SHORT || tok.kind==INT || tok.kind==LONG
119 || tok.kind==FLOAT || tok.kind==DOUBLE;
120 }
121
122 private int typeArguments(int x) {
123 int level = 1;
124 while (true) {
125 Token tok = getToken(++x);
126 if (tok.kind==GT) {
127 --level;
128 if (level==0) {
129 return x+1;
130 } else if (level < 0) {
131 return -1; }
133 } else if (tok.kind==RSIGNEDSHIFT) {
134 level -= 2;
135 if (level==0) {
136 return x+1;
137 } else if (level < 0) {
138 return -1; }
140 } else if (tok.kind==RUNSIGNEDSHIFT) {
141 level -= 2;
142 if (level==0) {
143 return x+1;
144 } else if (level < 0) {
145 return -1; }
147 } else if (tok.kind==LT) {
148 level++;
149 }
150
151 if (tok.kind==RPAREN) {
152 return -1;
153 } else if (tok.kind==DOT) {
154 } else if (tok.kind==HOOK || tok.kind==SUPER || tok.kind==EXTENDS || tok.kind==IDENTIFIER) {
155 }
157 }
158 }
159
160
161 private boolean castEnd(Token tok) {
162 return ( tok.kind==TILDE || tok.kind==BANG || tok.kind==LPAREN || tok.kind==IDENTIFIER
163 || tok.kind==THIS || tok.kind==SUPER || tok.kind==NEW
164 || tok.kind==INTEGER_LITERAL || tok.kind==FLOATING_POINT_LITERAL
165 || tok.kind==CHARACTER_LITERAL || tok.kind==STRING_LITERAL
166 || tok.kind==TRUE || tok.kind==FALSE || tok.kind==NULL );
167 }
168
169
170 public static void main(String args[]) {
171 }
172
173
176 final public void ReferenceTypeList() throws ParseException {
177
178 SimpleNode jjtn000 = new SimpleNode(JJTREFERENCETYPELIST);
179 boolean jjtc000 = true;
180 jjtree.openNodeScope(jjtn000);Token tok;
181 Token tok1;
182 Token tok2;
183 Token tok3;
184 try {
185 tok = jj_consume_token(LT);
186 if (!jdk1_5) {
187 {if (true) throw new ParseException("Generic reference types are only available in JDK 1.5 or later generics" );}
188 }
189 ActualTypeArgument();
190 label_1:
191 while (true) {
192 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
193 case COMMA:
194 ;
195 break;
196 default:
197 jj_la1[0] = jj_gen;
198 break label_1;
199 }
200 tok = jj_consume_token(COMMA);
201 ActualTypeArgument();
202 }
203 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
204 case GT:
205 tok = jj_consume_token(GT);
206 break;
207 case RSIGNEDSHIFT:
208 tok = jj_consume_token(RSIGNEDSHIFT);
209 jjtree.closeNodeScope(jjtn000, true);
210 jjtc000 = false;
211 tok2=tok.next;
212 tok1=Token.newToken(GT);
213 tok.image=">"; tok.kind=GT; tok.next=tok1;
214 tok1.image=">"; tok1.kind=GT; tok1.next=tok2;
215 break;
216 case RUNSIGNEDSHIFT:
217 tok = jj_consume_token(RUNSIGNEDSHIFT);
218 jjtree.closeNodeScope(jjtn000, true);
219 jjtc000 = false;
220 tok3=tok.next;
221 tok1=Token.newToken(GT); tok2=Token.newToken(GT);
222 tok.image=">"; tok.kind=GT; tok.next=tok1;
223 tok1.image=">"; tok1.kind=GT; tok1.next=tok2;
224 tok2.image=">"; tok2.kind=GT; tok2.next=tok3;
225 break;
226 default:
227 jj_la1[1] = jj_gen;
228 jj_consume_token(-1);
229 throw new ParseException();
230 }
231 } catch (Throwable jjte000) {
232 if (jjtc000) {
233 jjtree.clearNodeScope(jjtn000);
234 jjtc000 = false;
235 } else {
236 jjtree.popNode();
237 }
238 if (jjte000 instanceof RuntimeException ) {
239 {if (true) throw (RuntimeException )jjte000;}
240 }
241 if (jjte000 instanceof ParseException) {
242 {if (true) throw (ParseException)jjte000;}
243 }
244 {if (true) throw (Error )jjte000;}
245 } finally {
246 if (jjtc000) {
247 jjtree.closeNodeScope(jjtn000, true);
248 }
249 }
250 }
251
252 final public void ActualTypeArgument() throws ParseException {
253
254 SimpleNode jjtn000 = new SimpleNode(JJTACTUALTYPEARGUMENT);
255 boolean jjtc000 = true;
256 jjtree.openNodeScope(jjtn000);Token tok;
257 try {
258 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
259 case HOOK:
260 tok = jj_consume_token(HOOK);
262 jjtn000.setAttribute("wildcard", tok);
263 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
264 case EXTENDS:
265 case SUPER:
266 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
267 case EXTENDS:
268 tok = jj_consume_token(EXTENDS);
269 jjtn000.setAttribute("token", tok);
270 break;
271 case SUPER:
272 tok = jj_consume_token(SUPER);
273 jjtn000.setAttribute("token", tok);
274 break;
275 default:
276 jj_la1[2] = jj_gen;
277 jj_consume_token(-1);
278 throw new ParseException();
279 }
280 ReferenceType();
281 break;
282 default:
283 jj_la1[3] = jj_gen;
284 ;
285 }
286 break;
287 case BOOLEAN:
288 case BYTE:
289 case CHAR:
290 case DOUBLE:
291 case FLOAT:
292 case INT:
293 case LONG:
294 case SHORT:
295 case IDENTIFIER:
296 ReferenceType();
297 break;
298 default:
299 jj_la1[4] = jj_gen;
300 jj_consume_token(-1);
301 throw new ParseException();
302 }
303 } catch (Throwable jjte000) {
304 if (jjtc000) {
305 jjtree.clearNodeScope(jjtn000);
306 jjtc000 = false;
307 } else {
308 jjtree.popNode();
309 }
310 if (jjte000 instanceof RuntimeException ) {
311 {if (true) throw (RuntimeException )jjte000;}
312 }
313 if (jjte000 instanceof ParseException) {
314 {if (true) throw (ParseException)jjte000;}
315 }
316 {if (true) throw (Error )jjte000;}
317 } finally {
318 if (jjtc000) {
319 jjtree.closeNodeScope(jjtn000, true);
320 }
321 }
322 }
323
324 final public void Identifier() throws ParseException {
325
326 SimpleNode jjtn000 = new SimpleNode(JJTIDENTIFIER);
327 boolean jjtc000 = true;
328 jjtree.openNodeScope(jjtn000);Token tok;
329 try {
330 tok = jj_consume_token(IDENTIFIER);
331 jjtree.closeNodeScope(jjtn000, true);
332 jjtc000 = false;
333 jjtn000.setAttribute("token", tok);
334 } finally {
335 if (jjtc000) {
336 jjtree.closeNodeScope(jjtn000, true);
337 }
338 }
339 }
340
341 final public void VariableInitializer() throws ParseException {
342 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
343 case LBRACE:
344 ArrayInitializer();
345 break;
346 default:
347 jj_la1[5] = jj_gen;
348 if (jj_2_1(1)) {
349 Expression();
350 } else {
351 jj_consume_token(-1);
352 throw new ParseException();
353 }
354 }
355 }
356
357 final public void ArrayInitializer() throws ParseException {
358
359 SimpleNode jjtn000 = new SimpleNode(JJTARRAYINITIALIZER);
360 boolean jjtc000 = true;
361 jjtree.openNodeScope(jjtn000);
362 try {
363 jj_consume_token(LBRACE);
364 if (jj_2_3(1)) {
365 VariableInitializer();
366 label_2:
367 while (true) {
368 if (jj_2_2(2)) {
369 ;
370 } else {
371 break label_2;
372 }
373 jj_consume_token(COMMA);
374 VariableInitializer();
375 }
376 } else {
377 ;
378 }
379 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
380 case COMMA:
381 jj_consume_token(COMMA);
382 break;
383 default:
384 jj_la1[6] = jj_gen;
385 ;
386 }
387 jj_consume_token(RBRACE);
388 } catch (Throwable jjte000) {
389 if (jjtc000) {
390 jjtree.clearNodeScope(jjtn000);
391 jjtc000 = false;
392 } else {
393 jjtree.popNode();
394 }
395 if (jjte000 instanceof RuntimeException ) {
396 {if (true) throw (RuntimeException )jjte000;}
397 }
398 if (jjte000 instanceof ParseException) {
399 {if (true) throw (ParseException)jjte000;}
400 }
401 {if (true) throw (Error )jjte000;}
402 } finally {
403 if (jjtc000) {
404 jjtree.closeNodeScope(jjtn000, true);
405 }
406 }
407 }
408
409
412 final public void Type() throws ParseException {
413 if (jj_2_4(2)) {
414 ReferenceType();
415 } else {
416 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
417 case BOOLEAN:
418 case BYTE:
419 case CHAR:
420 case DOUBLE:
421 case FLOAT:
422 case INT:
423 case LONG:
424 case SHORT:
425 PrimitiveType();
426 break;
427 default:
428 jj_la1[7] = jj_gen;
429 jj_consume_token(-1);
430 throw new ParseException();
431 }
432 }
433 }
434
435 final public void ReferenceType() throws ParseException {
436
437 SimpleNode jjtn000 = new SimpleNode(JJTREFERENCETYPE);
438 boolean jjtc000 = true;
439 jjtree.openNodeScope(jjtn000);int arrayCount = 0;
440 try {
441 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
442 case IDENTIFIER:
443 ClassOrInterfaceType();
444 label_3:
445 while (true) {
446 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
447 case LBRACKET:
448 ;
449 break;
450 default:
451 jj_la1[8] = jj_gen;
452 break label_3;
453 }
454 jj_consume_token(LBRACKET);
455 jj_consume_token(RBRACKET);
456 arrayCount++;
457 }
458 jjtree.closeNodeScope(jjtn000, true);
459 jjtc000 = false;
460 jjtn000.setAttribute("arrayCount", new Integer (arrayCount));
461 break;
462 case BOOLEAN:
463 case BYTE:
464 case CHAR:
465 case DOUBLE:
466 case FLOAT:
467 case INT:
468 case LONG:
469 case SHORT:
470 PrimitiveType();
471 label_4:
472 while (true) {
473 jj_consume_token(LBRACKET);
474 jj_consume_token(RBRACKET);
475 arrayCount++;
476 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
477 case LBRACKET:
478 ;
479 break;
480 default:
481 jj_la1[9] = jj_gen;
482 break label_4;
483 }
484 }
485 jjtree.closeNodeScope(jjtn000, true);
486 jjtc000 = false;
487 jjtn000.setAttribute("arrayCount", new Integer (arrayCount));
488 break;
489 default:
490 jj_la1[10] = jj_gen;
491 jj_consume_token(-1);
492 throw new ParseException();
493 }
494 } catch (Throwable jjte000) {
495 if (jjtc000) {
496 jjtree.clearNodeScope(jjtn000);
497 jjtc000 = false;
498 } else {
499 jjtree.popNode();
500 }
501 if (jjte000 instanceof RuntimeException ) {
502 {if (true) throw (RuntimeException )jjte000;}
503 }
504 if (jjte000 instanceof ParseException) {
505 {if (true) throw (ParseException)jjte000;}
506 }
507 {if (true) throw (Error )jjte000;}
508 } finally {
509 if (jjtc000) {
510 jjtree.closeNodeScope(jjtn000, true);
511 }
512 }
513 }
514
515 final public void TypeArguments() throws ParseException {
516
517 SimpleNode jjtn000 = new SimpleNode(JJTTYPEARGUMENTS);
518 boolean jjtc000 = true;
519 jjtree.openNodeScope(jjtn000);Token tok;
520 Token tok1;
521 Token tok2;
522 Token tok3;
523 try {
524 tok = jj_consume_token(LT);
525 if (!jdk1_5) {
526 {if (true) throw new ParseException("Generic type arguments are only available in JDK 1.5 or later generics" );}
527 }
528 ActualTypeArgument();
529 label_5:
530 while (true) {
531 if (jj_2_5(2)) {
532 ;
533 } else {
534 break label_5;
535 }
536 tok = jj_consume_token(COMMA);
537 ActualTypeArgument();
538 }
539 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
540 case GT:
541 tok = jj_consume_token(GT);
542 break;
543 case RSIGNEDSHIFT:
544 tok = jj_consume_token(RSIGNEDSHIFT);
545 jjtree.closeNodeScope(jjtn000, true);
546 jjtc000 = false;
547 tok2=tok.next;
548 tok1=Token.newToken(GT);
549 tok.image=">"; tok.kind=GT; tok.next=tok1;
550 tok1.image=">"; tok1.kind=GT; tok1.next=tok2;
551 break;
552 case RUNSIGNEDSHIFT:
553 tok = jj_consume_token(RUNSIGNEDSHIFT);
554 jjtree.closeNodeScope(jjtn000, true);
555 jjtc000 = false;
556 tok3=tok.next;
557 tok1=Token.newToken(GT); tok2=Token.newToken(GT);
558 tok.image=">"; tok.kind=GT; tok.next=tok1;
559 tok1.image=">"; tok1.kind=GT; tok1.next=tok2;
560 tok2.image=">"; tok2.kind=GT; tok2.next=tok3;
561 break;
562 default:
563 jj_la1[11] = jj_gen;
564 jj_consume_token(-1);
565 throw new ParseException();
566 }
567 } catch (Throwable jjte000) {
568 if (jjtc000) {
569 jjtree.clearNodeScope(jjtn000);
570 jjtc000 = false;
571 } else {
572 jjtree.popNode();
573 }
574 if (jjte000 instanceof RuntimeException ) {
575 {if (true) throw (RuntimeException )jjte000;}
576 }
577 if (jjte000 instanceof ParseException) {
578 {if (true) throw (ParseException)jjte000;}
579 }
580 {if (true) throw (Error )jjte000;}
581 } finally {
582 if (jjtc000) {
583 jjtree.closeNodeScope(jjtn000, true);
584 }
585 }
586 }
587
588 final public void PrimitiveType() throws ParseException {
589
590 SimpleNode jjtn000 = new SimpleNode(JJTPRIMITIVETYPE);
591 boolean jjtc000 = true;
592 jjtree.openNodeScope(jjtn000);Token tok;
593 try {
594 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
595 case BOOLEAN:
596 tok = jj_consume_token(BOOLEAN);
597 break;
598 case CHAR:
599 tok = jj_consume_token(CHAR);
600 break;
601 case BYTE:
602 tok = jj_consume_token(BYTE);
603 break;
604 case SHORT:
605 tok = jj_consume_token(SHORT);
606 break;
607 case INT:
608 tok = jj_consume_token(INT);
609 break;
610 case LONG:
611 tok = jj_consume_token(LONG);
612 break;
613 case FLOAT:
614 tok = jj_consume_token(FLOAT);
615 break;
616 case DOUBLE:
617 tok = jj_consume_token(DOUBLE);
618 break;
619 default:
620 jj_la1[12] = jj_gen;
621 jj_consume_token(-1);
622 throw new ParseException();
623 }
624 jjtree.closeNodeScope(jjtn000, true);
625 jjtc000 = false;
626 jjtn000.setAttribute("token", tok);
627 } finally {
628 if (jjtc000) {
629 jjtree.closeNodeScope(jjtn000, true);
630 }
631 }
632 }
633
634 final public void ResultType() throws ParseException {
635
636 SimpleNode jjtn000 = new SimpleNode(JJTRESULTTYPE);
637 boolean jjtc000 = true;
638 jjtree.openNodeScope(jjtn000);
639 try {
640 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
641 case VOID:
642 jj_consume_token(VOID);
643 jjtree.closeNodeScope(jjtn000, true);
644 jjtc000 = false;
645 jjtn000.setAttribute("void", "void");
646 break;
647 case BOOLEAN:
648 case BYTE:
649 case CHAR:
650 case DOUBLE:
651 case FLOAT:
652 case INT:
653 case LONG:
654 case SHORT:
655 case IDENTIFIER:
656 Type();
657 break;
658 default:
659 jj_la1[13] = jj_gen;
660 jj_consume_token(-1);
661 throw new ParseException();
662 }
663 } catch (Throwable jjte000) {
664 if (jjtc000) {
665 jjtree.clearNodeScope(jjtn000);
666 jjtc000 = false;
667 } else {
668 jjtree.popNode();
669 }
670 if (jjte000 instanceof RuntimeException ) {
671 {if (true) throw (RuntimeException )jjte000;}
672 }
673 if (jjte000 instanceof ParseException) {
674 {if (true) throw (ParseException)jjte000;}
675 }
676 {if (true) throw (Error )jjte000;}
677 } finally {
678 if (jjtc000) {
679 jjtree.closeNodeScope(jjtn000, true);
680 }
681 }
682 }
683
684 final public void Name() throws ParseException {
685
686 SimpleNode jjtn000 = new SimpleNode(JJTNAME);
687 boolean jjtc000 = true;
688 jjtree.openNodeScope(jjtn000);Token tok;
689 try {
690 tok = jj_consume_token(IDENTIFIER);
691 jjtn000.addAttribute("token", tok);
692 label_6:
693 while (true) {
694 if (jj_2_6(2)) {
695 ;
696 } else {
697 break label_6;
698 }
699 jj_consume_token(DOT);
700 tok = jj_consume_token(IDENTIFIER);
701 jjtn000.addAttribute("token", tok);
702 }
703 } finally {
704 if (jjtc000) {
705 jjtree.closeNodeScope(jjtn000, true);
706 }
707 }
708 }
709
710 final public void ClassOrInterfaceType() throws ParseException {
711
712 SimpleNode jjtn000 = new SimpleNode(JJTCLASSORINTERFACETYPE);
713 boolean jjtc000 = true;
714 jjtree.openNodeScope(jjtn000);
715 try {
716 Identifier();
717 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
718 case LT:
719 TypeArguments();
720 break;
721 default:
722 jj_la1[14] = jj_gen;
723 ;
724 }
725 label_7:
726 while (true) {
727 if (jj_2_7(2147483647)) {
728 ;
729 } else {
730 break label_7;
731 }
732 jj_consume_token(DOT);
733 Identifier();
734 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
735 case LT:
736 TypeArguments();
737 break;
738 default:
739 jj_la1[15] = jj_gen;
740 ;
741 }
742 }
743 } catch (Throwable jjte000) {
744 if (jjtc000) {
745 jjtree.clearNodeScope(jjtn000);
746 jjtc000 = false;
747 } else {
748 jjtree.popNode();
749 }
750 if (jjte000 instanceof RuntimeException ) {
751 {if (true) throw (RuntimeException )jjte000;}
752 }
753 if (jjte000 instanceof ParseException) {
754 {if (true) throw (ParseException)jjte000;}
755 }
756 {if (true) throw (Error )jjte000;}
757 } finally {
758 if (jjtc000) {
759 jjtree.closeNodeScope(jjtn000, true);
760 }
761 }
762 }
763
764
767 final public SimpleNode Expression() throws ParseException {
768
769 SimpleNode jjtn000 = new SimpleNode(JJTEXPRESSION);
770 boolean jjtc000 = true;
771 jjtree.openNodeScope(jjtn000);
772 try {
773 ConditionalExpression();
774 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
775 case ASSIGN:
776 case PLUSASSIGN:
777 case MINUSASSIGN:
778 case STARASSIGN:
779 case SLASHASSIGN:
780 case ANDASSIGN:
781 case ORASSIGN:
782 case XORASSIGN:
783 case REMASSIGN:
784 case LSHIFTASSIGN:
785 case RSIGNEDSHIFTASSIGN:
786 case RUNSIGNEDSHIFTASSIGN:
787 AssignmentOperator();
788 Expression();
789 break;
790 default:
791 jj_la1[16] = jj_gen;
792 ;
793 }
794 jjtree.closeNodeScope(jjtn000, true);
795 jjtc000 = false;
796 {if (true) return jjtn000;}
797 } catch (Throwable jjte000) {
798 if (jjtc000) {
799 jjtree.clearNodeScope(jjtn000);
800 jjtc000 = false;
801 } else {
802 jjtree.popNode();
803 }
804 if (jjte000 instanceof RuntimeException ) {
805 {if (true) throw (RuntimeException )jjte000;}
806 }
807 if (jjte000 instanceof ParseException) {
808 {if (true) throw (ParseException)jjte000;}
809 }
810 {if (true) throw (Error )jjte000;}
811 } finally {
812 if (jjtc000) {
813 jjtree.closeNodeScope(jjtn000, true);
814 }
815 }
816 throw new Error ("Missing return statement in function");
817 }
818
819 final public void AssignmentOperator() throws ParseException {
820
821 SimpleNode jjtn000 = new SimpleNode(JJTASSIGNMENTOPERATOR);
822 boolean jjtc000 = true;
823 jjtree.openNodeScope(jjtn000);Token tok;
824 try {
825 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
826 case ASSIGN:
827 tok = jj_consume_token(ASSIGN);
828 break;
829 case STARASSIGN:
830 tok = jj_consume_token(STARASSIGN);
831 break;
832 case SLASHASSIGN:
833 tok = jj_consume_token(SLASHASSIGN);
834 break;
835 case REMASSIGN:
836 tok = jj_consume_token(REMASSIGN);
837 break;
838 case PLUSASSIGN:
839 tok = jj_consume_token(PLUSASSIGN);
840 break;
841 case MINUSASSIGN:
842 tok = jj_consume_token(MINUSASSIGN);
843 break;
844 case LSHIFTASSIGN:
845 tok = jj_consume_token(LSHIFTASSIGN);
846 break;
847 case RSIGNEDSHIFTASSIGN:
848 tok = jj_consume_token(RSIGNEDSHIFTASSIGN);
849 break;
850 case RUNSIGNEDSHIFTASSIGN:
851 tok = jj_consume_token(RUNSIGNEDSHIFTASSIGN);
852 break;
853 case ANDASSIGN:
854 tok = jj_consume_token(ANDASSIGN);
855 break;
856 case XORASSIGN:
857 tok = jj_consume_token(XORASSIGN);
858 break;
859 case ORASSIGN:
860 tok = jj_consume_token(ORASSIGN);
861 break;
862 default:
863 jj_la1[17] = jj_gen;
864 jj_consume_token(-1);
865 throw new ParseException();
866 }
867 jjtree.closeNodeScope(jjtn000, true);
868 jjtc000 = false;
869 jjtn000.setAttribute("operator", tok);
870 } finally {
871 if (jjtc000) {
872 jjtree.closeNodeScope(jjtn000, true);
873 }
874 }
875 }
876
877 final public void ConditionalExpression() throws ParseException {
878 SimpleNode jjtn001 = new SimpleNode(JJTCONDITIONALEXPRESSION);
879 boolean jjtc001 = true;
880 jjtree.openNodeScope(jjtn001);
881 try {
882 ConditionalOrExpression();
883 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
884 case HOOK:
885 jj_consume_token(HOOK);
886 Expression();
887 jj_consume_token(COLON);
888 ConditionalExpression();
889 break;
890 default:
891 jj_la1[18] = jj_gen;
892 ;
893 }
894 } catch (Throwable jjte001) {
895 if (jjtc001) {
896 jjtree.clearNodeScope(jjtn001);
897 jjtc001 = false;
898 } else {
899 jjtree.popNode();
900 }
901 if (jjte001 instanceof RuntimeException ) {
902 {if (true) throw (RuntimeException )jjte001;}
903 }
904 if (jjte001 instanceof ParseException) {
905 {if (true) throw (ParseException)jjte001;}
906 }
907 {if (true) throw (Error )jjte001;}
908 } finally {
909 if (jjtc001) {
910 jjtree.closeNodeScope(jjtn001, jjtree.nodeArity() > 1);
911 }
912 }
913 }
914
915 final public void ConditionalOrExpression() throws ParseException {
916 Token tok;
917 SimpleNode jjtn001 = new SimpleNode(JJTCONDITIONALOREXPRESSION);
918 boolean jjtc001 = true;
919 jjtree.openNodeScope(jjtn001);
920 try {
921 ConditionalAndExpression();
922 label_8:
923 while (true) {
924 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
925 case SC_OR:
926 ;
927 break;
928 default:
929 jj_la1[19] = jj_gen;
930 break label_8;
931 }
932 tok = jj_consume_token(SC_OR);
933 jjtn001.setAttribute("operator", tok);
934 ConditionalAndExpression();
935 }
936 } catch (Throwable jjte001) {
937 if (jjtc001) {
938 jjtree.clearNodeScope(jjtn001);
939 jjtc001 = false;
940 } else {
941 jjtree.popNode();
942 }
943 if (jjte001 instanceof RuntimeException ) {
944 {if (true) throw (RuntimeException )jjte001;}
945 }
946 if (jjte001 instanceof ParseException) {
947 {if (true) throw (ParseException)jjte001;}
948 }
949 {if (true) throw (Error )jjte001;}
950 } finally {
951 if (jjtc001) {
952 jjtree.closeNodeScope(jjtn001, jjtree.nodeArity() > 1);
953 }
954 }
955 }
956
957 final public void ConditionalAndExpression() throws ParseException {
958 Token tok;
959 SimpleNode jjtn001 = new SimpleNode(JJTCONDITIONALANDEXPRESSION);
960 boolean jjtc001 = true;
961 jjtree.openNodeScope(jjtn001);
962 try {
963 InclusiveOrExpression();
964 label_9:
965 while (true) {
966 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
967 case SC_AND:
968 ;
969 break;
970 default:
971 jj_la1[20] = jj_gen;
972 break label_9;
973 }
974 tok = jj_consume_token(SC_AND);
975 jjtn001.setAttribute("operator", tok);
976 InclusiveOrExpression();
977 }
978 } catch (Throwable jjte001) {
979 if (jjtc001) {
980 jjtree.clearNodeScope(jjtn001);
981 jjtc001 = false;
982 } else {
983 jjtree.popNode();
984 }
985 if (jjte001 instanceof RuntimeException ) {
986 {if (true) throw (RuntimeException )jjte001;}
987 }
988 if (jjte001 instanceof ParseException) {
989 {if (true) throw (ParseException)jjte001;}
990 }
991 {if (true) throw (Error )jjte001;}
992 } finally {
993 if (jjtc001) {
994 jjtree.closeNodeScope(jjtn001, jjtree.nodeArity() > 1);
995 }
996 }
997 }
998
999 final public void InclusiveOrExpression() throws ParseException {
1000 Token tok;
1001 SimpleNode jjtn001 = new SimpleNode(JJTINCLUSIVEOREXPRESSION);
1002 boolean jjtc001 = true;
1003 jjtree.openNodeScope(jjtn001);
1004 try {
1005 ExclusiveOrExpression();
1006 label_10:
1007 while (true) {
1008 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1009 case BIT_OR:
1010 ;
1011 break;
1012 default:
1013 jj_la1[21] = jj_gen;
1014 break label_10;
1015 }
1016 tok = jj_consume_token(BIT_OR);
1017 jjtn001.addAttribute("operator", tok);
1018 ExclusiveOrExpression();
1019 }
1020 } catch (Throwable jjte001) {
1021 if (jjtc001) {
1022 jjtree.clearNodeScope(jjtn001);
1023 jjtc001 = false;
1024 } else {
1025 jjtree.popNode();
1026 }
1027 if (jjte001 instanceof RuntimeException ) {
1028 {if (true) throw (RuntimeException )jjte001;}
1029 }
1030 if (jjte001 instanceof ParseException) {
1031 {if (true) throw (ParseException)jjte001;}
1032 }
1033 {if (true) throw (Error )jjte001;}
1034 } finally {
1035 if (jjtc001) {
1036 jjtree.closeNodeScope(jjtn001, jjtree.nodeArity() > 1);
1037 }
1038 }
1039 }
1040
1041 final public void ExclusiveOrExpression() throws ParseException {
1042 Token tok;
1043 SimpleNode jjtn001 = new SimpleNode(JJTEXCLUSIVEOREXPRESSION);
1044 boolean jjtc001 = true;
1045 jjtree.openNodeScope(jjtn001);
1046 try {
1047 AndExpression();
1048 label_11:
1049 while (true) {
1050 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1051 case XOR:
1052 ;
1053 break;
1054 default:
1055 jj_la1[22] = jj_gen;
1056 break label_11;
1057 }
1058 tok = jj_consume_token(XOR);
1059 jjtn001.addAttribute("operator", tok);
1060 AndExpression();
1061 }
1062 } catch (Throwable jjte001) {
1063 if (jjtc001) {
1064 jjtree.clearNodeScope(jjtn001);
1065 jjtc001 = false;
1066 } else {
1067 jjtree.popNode();
1068 }
1069 if (jjte001 instanceof RuntimeException ) {
1070 {if (true) throw (RuntimeException )jjte001;}
1071 }
1072 if (jjte001 instanceof ParseException) {
1073 {if (true) throw (ParseException)jjte001;}
1074 }
1075 {if (true) throw (Error )jjte001;}
1076 } finally {
1077 if (jjtc001) {
1078 jjtree.closeNodeScope(jjtn001, jjtree.nodeArity() > 1);
1079 }
1080 }
1081 }
1082
1083 final public void AndExpression() throws ParseException {
1084 Token tok;
1085 SimpleNode jjtn001 = new SimpleNode(JJTANDEXPRESSION);
1086 boolean jjtc001 = true;
1087 jjtree.openNodeScope(jjtn001);
1088 try {
1089 EqualityExpression();
1090 label_12:
1091 while (true) {
1092 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1093 case BIT_AND:
1094 ;
1095 break;
1096 default:
1097 jj_la1[23] = jj_gen;
1098 break label_12;
1099 }
1100 tok = jj_consume_token(BIT_AND);
1101 jjtn001.addAttribute("operator", tok);
1102 EqualityExpression();
1103 }
1104 } catch (Throwable jjte001) {
1105 if (jjtc001) {
1106 jjtree.clearNodeScope(jjtn001);
1107 jjtc001 = false;
1108 } else {
1109 jjtree.popNode();
1110 }
1111 if (jjte001 instanceof RuntimeException ) {
1112 {if (true) throw (RuntimeException )jjte001;}
1113 }
1114 if (jjte001 instanceof ParseException) {
1115 {if (true) throw (ParseException)jjte001;}
1116 }
1117 {if (true) throw (Error )jjte001;}
1118 } finally {
1119 if (jjtc001) {
1120 jjtree.closeNodeScope(jjtn001, jjtree.nodeArity() > 1);
1121 }
1122 }
1123 }
1124
1125 final public void EqualityExpression() throws ParseException {
1126 Token tok;
1127 SimpleNode jjtn001 = new SimpleNode(JJTEQUALITYEXPRESSION);
1128 boolean jjtc001 = true;
1129 jjtree.openNodeScope(jjtn001);
1130 try {
1131 InstanceOfExpression();
1132 label_13:
1133 while (true) {
1134 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1135 case EQ:
1136 case NE:
1137 ;
1138 break;
1139 default:
1140 jj_la1[24] = jj_gen;
1141 break label_13;
1142 }
1143 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1144 case EQ:
1145 tok = jj_consume_token(EQ);
1146 break;
1147 case NE:
1148 tok = jj_consume_token(NE);
1149 break;
1150 default:
1151 jj_la1[25] = jj_gen;
1152 jj_consume_token(-1);
1153 throw new ParseException();
1154 }
1155 jjtn001.addAttribute("operator", tok);
1156 InstanceOfExpression();
1157 }
1158 } catch (Throwable jjte001) {
1159 if (jjtc001) {
1160 jjtree.clearNodeScope(jjtn001);
1161 jjtc001 = false;
1162 } else {
1163 jjtree.popNode();
1164 }
1165 if (jjte001 instanceof RuntimeException ) {
1166 {if (true) throw (RuntimeException )jjte001;}
1167 }
1168 if (jjte001 instanceof ParseException) {
1169 {if (true) throw (ParseException)jjte001;}
1170 }
1171 {if (true) throw (Error )jjte001;}
1172 } finally {
1173 if (jjtc001) {
1174 jjtree.closeNodeScope(jjtn001, jjtree.nodeArity() > 1);
1175 }
1176 }
1177 }
1178
1179 final public void InstanceOfExpression() throws ParseException {
1180 SimpleNode jjtn001 = new SimpleNode(JJTINSTANCEOFEXPRESSION);
1181 boolean jjtc001 = true;
1182 jjtree.openNodeScope(jjtn001);
1183 try {
1184 RelationalExpression();
1185 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1186 case INSTANCEOF:
1187 jj_consume_token(INSTANCEOF);
1188 ReferenceType();
1189 break;
1190 default:
1191 jj_la1[26] = jj_gen;
1192 ;
1193 }
1194 } catch (Throwable jjte001) {
1195 if (jjtc001) {
1196 jjtree.clearNodeScope(jjtn001);
1197 jjtc001 = false;
1198 } else {
1199 jjtree.popNode();
1200 }
1201 if (jjte001 instanceof RuntimeException ) {
1202 {if (true) throw (RuntimeException )jjte001;}
1203 }
1204 if (jjte001 instanceof ParseException) {
1205 {if (true) throw (ParseException)jjte001;}
1206 }
1207 {if (true) throw (Error )jjte001;}
1208 } finally {
1209 if (jjtc001) {
1210 jjtree.closeNodeScope(jjtn001, jjtree.nodeArity() > 1);
1211 }
1212 }
1213 }
1214
1215 final public void RelationalExpression() throws ParseException {
1216 SimpleNode jjtn001 = new SimpleNode(JJTRELATIONALEXPRESSION);
1217 boolean jjtc001 = true;
1218 jjtree.openNodeScope(jjtn001);
1219 try {
1220 ShiftExpression();
1221 label_14:
1222 while (true) {
1223 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1224 case GT:
1225 case LT:
1226 case LE:
1227 case GE:
1228 ;
1229 break;
1230 default:
1231 jj_la1[27] = jj_gen;
1232 break label_14;
1233 }
1234 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1235 case LT:
1236 jj_consume_token(LT);
1237 break;
1238 case GT:
1239 jj_consume_token(GT);
1240 break;
1241 case LE:
1242 jj_consume_token(LE);
1243 break;
1244 case GE:
1245 jj_consume_token(GE);
1246 break;
1247 default:
1248 jj_la1[28] = jj_gen;
1249 jj_consume_token(-1);
1250 throw new ParseException();
1251 }
1252 jjtn001.addAttribute("operator", token);
1253 ShiftExpression();
1254 }
1255 } catch (Throwable jjte001) {
1256 if (jjtc001) {
1257 jjtree.clearNodeScope(jjtn001);
1258 jjtc001 = false;
1259 } else {
1260 jjtree.popNode();
1261 }
1262 if (jjte001 instanceof RuntimeException ) {
1263 {if (true) throw (RuntimeException )jjte001;}
1264 }
1265 if (jjte001 instanceof ParseException) {
1266 {if (true) throw (ParseException)jjte001;}
1267 }
1268 {if (true) throw (Error )jjte001;}
1269 } finally {
1270 if (jjtc001) {
1271 jjtree.closeNodeScope(jjtn001, jjtree.nodeArity() > 1);
1272 }
1273 }
1274 }
1275
1276 final public void ShiftExpression() throws ParseException {
1277 Token tok;
1278 SimpleNode jjtn001 = new SimpleNode(JJTSHIFTEXPRESSION);
1279 boolean jjtc001 = true;
1280 jjtree.openNodeScope(jjtn001);
1281 try {
1282 AdditiveExpression();
1283 label_15:
1284 while (true) {
1285 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1286 case LSHIFT:
1287 case RSIGNEDSHIFT:
1288 case RUNSIGNEDSHIFT:
1289 ;
1290 break;
1291 default:
1292 jj_la1[29] = jj_gen;
1293 break label_15;
1294 }
1295 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1296 case LSHIFT:
1297 tok = jj_consume_token(LSHIFT);
1298 break;
1299 case RSIGNEDSHIFT:
1300 tok = jj_consume_token(RSIGNEDSHIFT);
1301 break;
1302 case RUNSIGNEDSHIFT:
1303 tok = jj_consume_token(RUNSIGNEDSHIFT);
1304 break;
1305 default:
1306 jj_la1[30] = jj_gen;
1307 jj_consume_token(-1);
1308 throw new ParseException();
1309 }
1310 jjtn001.addAttribute("operator", tok);
1311 AdditiveExpression();
1312 }
1313 } catch (Throwable jjte001) {
1314 if (jjtc001) {
1315 jjtree.clearNodeScope(jjtn001);
1316 jjtc001 = false;
1317 } else {
1318 jjtree.popNode();
1319 }
1320 if (jjte001 instanceof RuntimeException ) {
1321 {if (true) throw (RuntimeException )jjte001;}
1322 }
1323 if (jjte001 instanceof ParseException) {
1324 {if (true) throw (ParseException)jjte001;}
1325 }
1326 {if (true) throw (Error )jjte001;}
1327 } finally {
1328 if (jjtc001) {
1329 jjtree.closeNodeScope(jjtn001, jjtree.nodeArity() > 1);
1330 }
1331 }
1332 }
1333
1334 final public void AdditiveExpression() throws ParseException {
1335 Token tok;
1336 SimpleNode jjtn001 = new SimpleNode(JJTADDITIVEEXPRESSION);
1337 boolean jjtc001 = true;
1338 jjtree.openNodeScope(jjtn001);
1339 try {
1340 MultiplicativeExpression();
1341 label_16:
1342 while (true) {
1343 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1344 case PLUS:
1345 case MINUS:
1346 ;
1347 break;
1348 default:
1349 jj_la1[31] = jj_gen;
1350 break label_16;
1351 }
1352 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1353 case PLUS:
1354 tok = jj_consume_token(PLUS);
1355 break;
1356 case MINUS:
1357 tok = jj_consume_token(MINUS);
1358 break;
1359 default:
1360 jj_la1[32] = jj_gen;
1361 jj_consume_token(-1);
1362 throw new ParseException();
1363 }
1364 jjtn001.addAttribute("operator", tok);
1365 MultiplicativeExpression();
1366 }
1367 } catch (Throwable jjte001) {
1368 if (jjtc001) {
1369 jjtree.clearNodeScope(jjtn001);
1370 jjtc001 = false;
1371 } else {
1372 jjtree.popNode();
1373 }
1374 if (jjte001 instanceof RuntimeException ) {
1375 {if (true) throw (RuntimeException )jjte001;}
1376 }
1377 if (jjte001 instanceof ParseException) {
1378 {if (true) throw (ParseException)jjte001;}
1379 }
1380 {if (true) throw (Error )jjte001;}
1381 } finally {
1382 if (jjtc001) {
1383 jjtree.closeNodeScope(jjtn001, jjtree.nodeArity() > 1);
1384 }
1385 }
1386 }
1387
1388 final public void MultiplicativeExpression() throws ParseException {
1389 Token tok;
1390 SimpleNode jjtn001 = new SimpleNode(JJTMULTIPLICATIVEEXPRESSION);
1391 boolean jjtc001 = true;
1392 jjtree.openNodeScope(jjtn001);
1393 try {
1394 UnaryExpression();
1395 label_17:
1396 while (true) {
1397 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1398 case STAR:
1399 case SLASH:
1400 case REM:
1401 ;
1402 break;
1403 default:
1404 jj_la1[33] = jj_gen;
1405 break label_17;
1406 }
1407 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1408 case STAR:
1409 tok = jj_consume_token(STAR);
1410 break;
1411 case SLASH:
1412 tok = jj_consume_token(SLASH);
1413 break;
1414 case REM:
1415 tok = jj_consume_token(REM);
1416 break;
1417 default:
1418 jj_la1[34] = jj_gen;
1419 jj_consume_token(-1);
1420 throw new ParseException();
1421 }
1422 jjtn001.addAttribute("operator", tok);
1423 UnaryExpression();
1424 }
1425 } catch (Throwable jjte001) {
1426 if (jjtc001) {
1427 jjtree.clearNodeScope(jjtn001);
1428 jjtc001 = false;
1429 } else {
1430 jjtree.popNode();
1431 }
1432 if (jjte001 instanceof RuntimeException ) {
1433 {if (true) throw (RuntimeException )jjte001;}
1434 }
1435 if (jjte001 instanceof ParseException) {
1436 {if (true) throw (ParseException)jjte001;}
1437 }
1438 {if (true) throw (Error )jjte001;}
1439 } finally {
1440 if (jjtc001) {
1441 jjtree.closeNodeScope(jjtn001, jjtree.nodeArity() > 1);
1442 }
1443 }
1444 }
1445
1446 final public void UnaryExpression() throws ParseException {
1447 Token tok = null;
1448 SimpleNode jjtn001 = new SimpleNode(JJTUNARYEXPRESSION);
1449 boolean jjtc001 = true;
1450 jjtree.openNodeScope(jjtn001);
1451 try {
1452 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1453 case PLUS:
1454 case MINUS:
1455 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1456 case PLUS:
1457 tok = jj_consume_token(PLUS);
1458 break;
1459 case MINUS:
1460 tok = jj_consume_token(MINUS);
1461 break;
1462 default:
1463 jj_la1[35] = jj_gen;
1464 jj_consume_token(-1);
1465 throw new ParseException();
1466 }
1467 jjtn001.setAttribute("operator", tok);
1468 UnaryExpression();
1469 break;
1470 case INCR:
1471 PreIncrementExpression();
1472 break;
1473 case DECR:
1474 PreDecrementExpression();
1475 break;
1476 default:
1477 jj_la1[36] = jj_gen;
1478 if (jj_2_8(1)) {
1479 UnaryExpressionNotPlusMinus();
1480 } else {
1481 jj_consume_token(-1);
1482 throw new ParseException();
1483 }
1484 }
1485 } catch (Throwable jjte001) {
1486 if (jjtc001) {
1487 jjtree.clearNodeScope(jjtn001);
1488 jjtc001 = false;
1489 } else {
1490 jjtree.popNode();
1491 }
1492 if (jjte001 instanceof RuntimeException ) {
1493 {if (true) throw (RuntimeException )jjte001;}
1494 }
1495 if (jjte001 instanceof ParseException) {
1496 {if (true) throw (ParseException)jjte001;}
1497 }
1498 {if (true) throw (Error )jjte001;}
1499 } finally {
1500 if (jjtc001) {
1501 jjtree.closeNodeScope(jjtn001, tok != null);
1502 }
1503 }
1504 }
1505
1506 final public void PreIncrementExpression() throws ParseException {
1507
1508 SimpleNode jjtn000 = new SimpleNode(JJTPREINCREMENTEXPRESSION);
1509 boolean jjtc000 = true;
1510 jjtree.openNodeScope(jjtn000);Token tok;
1511 try {
1512 tok = jj_consume_token(INCR);
1513 jjtn000.setAttribute("operator", tok);
1514 PrimaryExpression();
1515 } catch (Throwable jjte000) {
1516 if (jjtc000) {
1517 jjtree.clearNodeScope(jjtn000);
1518 jjtc000 = false;
1519 } else {
1520 jjtree.popNode();
1521 }
1522 if (jjte000 instanceof RuntimeException ) {
1523 {if (true) throw (RuntimeException )jjte000;}
1524 }
1525 if (jjte000 instanceof ParseException) {
1526 {if (true) throw (ParseException)jjte000;}
1527 }
1528 {if (true) throw (Error )jjte000;}
1529 } finally {
1530 if (jjtc000) {
1531 jjtree.closeNodeScope(jjtn000, true);
1532 }
1533 }
1534 }
1535
1536 final public void PreDecrementExpression() throws ParseException {
1537
1538 SimpleNode jjtn000 = new SimpleNode(JJTPREDECREMENTEXPRESSION);
1539 boolean jjtc000 = true;
1540 jjtree.openNodeScope(jjtn000);Token tok;
1541 try {
1542 tok = jj_consume_token(DECR);
1543 jjtn000.setAttribute("operator", tok);
1544 PrimaryExpression();
1545 } catch (Throwable jjte000) {
1546 if (jjtc000) {
1547 jjtree.clearNodeScope(jjtn000);
1548 jjtc000 = false;
1549 } else {
1550 jjtree.popNode();
1551 }
1552 if (jjte000 instanceof RuntimeException ) {
1553 {if (true) throw (RuntimeException )jjte000;}
1554 }
1555 if (jjte000 instanceof ParseException) {
1556 {if (true) throw (ParseException)jjte000;}
1557 }
1558 {if (true) throw (Error )jjte000;}
1559 } finally {
1560 if (jjtc000) {
1561 jjtree.closeNodeScope(jjtn000, true);
1562 }
1563 }
1564 }
1565
1566 final public void UnaryExpressionNotPlusMinus() throws ParseException {
1567 Token tok = null;
1568 SimpleNode jjtn001 = new SimpleNode(JJTUNARYEXPRESSIONNOTPLUSMINUS);
1569 boolean jjtc001 = true;
1570 jjtree.openNodeScope(jjtn001);
1571 try {
1572 if (castLookahead()) {
1573 CastExpression();
1574 } else {
1575 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1576 case BANG:
1577 case TILDE:
1578 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1579 case TILDE:
1580 tok = jj_consume_token(TILDE);
1581 break;
1582 case BANG:
1583 tok = jj_consume_token(BANG);
1584 break;
1585 default:
1586 jj_la1[37] = jj_gen;
1587 jj_consume_token(-1);
1588 throw new ParseException();
1589 }
1590 jjtn001.setAttribute("operator", tok);
1591 UnaryExpression();
1592 break;
1593 case BOOLEAN:
1594 case BYTE:
1595 case CHAR:
1596 case DOUBLE:
1597 case FALSE:
1598 case FLOAT:
1599 case INT:
1600 case LONG:
1601 case NEW:
1602 case NULL:
1603 case SHORT:
1604 case SUPER:
1605 case THIS:
1606 case TRUE:
1607 case VOID:
1608 case INTEGER_LITERAL:
1609 case FLOATING_POINT_LITERAL:
1610 case CHARACTER_LITERAL:
1611 case STRING_LITERAL:
1612 case IDENTIFIER:
1613 case LPAREN:
1614 PostfixExpression();
1615 break;
1616 default:
1617 jj_la1[38] = jj_gen;
1618 jj_consume_token(-1);
1619 throw new ParseException();
1620 }
1621 }
1622 } catch (Throwable jjte001) {
1623 if (jjtc001) {
1624 jjtree.clearNodeScope(jjtn001);
1625 jjtc001 = false;
1626 } else {
1627 jjtree.popNode();
1628 }
1629 if (jjte001 instanceof RuntimeException ) {
1630 {if (true) throw (RuntimeException )jjte001;}
1631 }
1632 if (jjte001 instanceof ParseException) {
1633 {if (true) throw (ParseException)jjte001;}
1634 }
1635 {if (true) throw (Error )jjte001;}
1636 } finally {
1637 if (jjtc001) {
1638 jjtree.closeNodeScope(jjtn001, tok != null);
1639 }
1640 }
1641 }
1642
1643 final public void PostfixExpression() throws ParseException {
1644 Token tok = null;
1645 SimpleNode jjtn001 = new SimpleNode(JJTPOSTFIXEXPRESSION);
1646 boolean jjtc001 = true;
1647 jjtree.openNodeScope(jjtn001);
1648 try {
1649 PrimaryExpression();
1650 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1651 case INCR:
1652 case DECR:
1653 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1654 case INCR:
1655 tok = jj_consume_token(INCR);
1656 break;
1657 case DECR:
1658 tok = jj_consume_token(DECR);
1659 break;
1660 default:
1661 jj_la1[39] = jj_gen;
1662 jj_consume_token(-1);
1663 throw new ParseException();
1664 }
1665 break;
1666 default:
1667 jj_la1[40] = jj_gen;
1668 ;
1669 }
1670 jjtree.closeNodeScope(jjtn001, tok != null);
1671 jjtc001 = false;
1672 if (tok != null) jjtn001.setAttribute("operator", token);
1673 } catch (Throwable jjte001) {
1674 if (jjtc001) {
1675 jjtree.clearNodeScope(jjtn001);
1676 jjtc001 = false;
1677 } else {
1678 jjtree.popNode();
1679 }
1680 if (jjte001 instanceof RuntimeException ) {
1681 {if (true) throw (RuntimeException )jjte001;}
1682 }
1683 if (jjte001 instanceof ParseException) {
1684 {if (true) throw (ParseException)jjte001;}
1685 }
1686 {if (true) throw (Error )jjte001;}
1687 } finally {
1688 if (jjtc001) {
1689 jjtree.closeNodeScope(jjtn001, tok != null);
1690 }
1691 }
1692 }
1693
1694 final public void CastExpression() throws ParseException {
1695
1696 SimpleNode jjtn000 = new SimpleNode(JJTCASTEXPRESSION);
1697 boolean jjtc000 = true;
1698 jjtree.openNodeScope(jjtn000);
1699 try {
1700 jj_consume_token(LPAREN);
1701 Type();
1702 jj_consume_token(RPAREN);
1703 UnaryExpression();
1704 } catch (Throwable jjte000) {
1705 if (jjtc000) {
1706 jjtree.clearNodeScope(jjtn000);
1707 jjtc000 = false;
1708 } else {
1709 jjtree.popNode();
1710 }
1711 if (jjte000 instanceof RuntimeException ) {
1712 {if (true) throw (RuntimeException )jjte000;}
1713 }
1714 if (jjte000 instanceof ParseException) {
1715 {if (true) throw (ParseException)jjte000;}
1716 }
1717 {if (true) throw (Error )jjte000;}
1718 } finally {
1719 if (jjtc000) {
1720 jjtree.closeNodeScope(jjtn000, true);
1721 }
1722 }
1723 }
1724
1725 final public void PrimaryExpression() throws ParseException {
1726 SimpleNode jjtn001 = new SimpleNode(JJTPRIMARYEXPRESSION);
1727 boolean jjtc001 = true;
1728 jjtree.openNodeScope(jjtn001);
1729 try {
1730 PrimaryPrefix();
1731 label_18:
1732 while (true) {
1733 if (jj_2_9(2147483647)) {
1734 ;
1735 } else {
1736 break label_18;
1737 }
1738 PrimarySuffix();
1739 }
1740 } catch (Throwable jjte001) {
1741 if (jjtc001) {
1742 jjtree.clearNodeScope(jjtn001);
1743 jjtc001 = false;
1744 } else {
1745 jjtree.popNode();
1746 }
1747 if (jjte001 instanceof RuntimeException ) {
1748 {if (true) throw (RuntimeException )jjte001;}
1749 }
1750 if (jjte001 instanceof ParseException) {
1751 {if (true) throw (ParseException)jjte001;}
1752 }
1753 {if (true) throw (Error )jjte001;}
1754 } finally {
1755 if (jjtc001) {
1756 jjtree.closeNodeScope(jjtn001, jjtree.nodeArity() > 0);
1757 }
1758 }
1759 }
1760
1761 final public void PrimaryPrefix() throws ParseException {
1762
1763 SimpleNode jjtn000 = new SimpleNode(JJTPRIMARYPREFIX);
1764 boolean jjtc000 = true;
1765 jjtree.openNodeScope(jjtn000);Token tok;
1766 String name = "";
1767 try {
1768 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1769 case FALSE:
1770 case NULL:
1771 case TRUE:
1772 case INTEGER_LITERAL:
1773 case FLOATING_POINT_LITERAL:
1774 case CHARACTER_LITERAL:
1775 case STRING_LITERAL:
1776 Literal();
1777 break;
1778 case THIS:
1779 tok = jj_consume_token(THIS);
1780 jjtree.closeNodeScope(jjtn000, true);
1781 jjtc000 = false;
1782 jjtn000.setAttribute("this", "this");
1783 break;
1784 default:
1785 jj_la1[42] = jj_gen;
1786 if (jj_2_10(2147483647)) {
1787 label_19:
1788 while (true) {
1789 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1790 case IDENTIFIER:
1791 ;
1792 break;
1793 default:
1794 jj_la1[41] = jj_gen;
1795 break label_19;
1796 }
1797 tok = jj_consume_token(IDENTIFIER);
1798 jj_consume_token(DOT);
1799 name = name + tok.image + ".";
1800 }
1801 jj_consume_token(SUPER);
1802 jj_consume_token(DOT);
1803 tok = jj_consume_token(IDENTIFIER);
1804 jjtree.closeNodeScope(jjtn000, true);
1805 jjtc000 = false;
1806 jjtn000.setAttribute("qualifier", (name.length() > 0) ? name.substring(0, name.length() - 1) : "");
1807 name = name + "super." + tok.image;
1808 jjtn000.setAttribute("identifier", tok.image);
1809 } else {
1810 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1811 case LPAREN:
1812 tok = jj_consume_token(LPAREN);
1813 Expression();
1814 tok = jj_consume_token(RPAREN);
1815 break;
1816 case NEW:
1817 AllocationExpression();
1818 break;
1819 default:
1820 jj_la1[43] = jj_gen;
1821 if (jj_2_11(2147483647)) {
1822 ResultType();
1823 jj_consume_token(DOT);
1824 jj_consume_token(CLASS);
1825 } else {
1826 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1827 case IDENTIFIER:
1828 Name();
1829 break;
1830 default:
1831 jj_la1[44] = jj_gen;
1832 jj_consume_token(-1);
1833 throw new ParseException();
1834 }
1835 }
1836 }
1837 }
1838 }
1839 } catch (Throwable jjte000) {
1840 if (jjtc000) {
1841 jjtree.clearNodeScope(jjtn000);
1842 jjtc000 = false;
1843 } else {
1844 jjtree.popNode();
1845 }
1846 if (jjte000 instanceof RuntimeException ) {
1847 {if (true) throw (RuntimeException )jjte000;}
1848 }
1849 if (jjte000 instanceof ParseException) {
1850 {if (true) throw (ParseException)jjte000;}
1851 }
1852 {if (true) throw (Error )jjte000;}
1853 } finally {
1854 if (jjtc000) {
1855 jjtree.closeNodeScope(jjtn000, true);
1856 }
1857 }
1858 }
1859
1860 final public void PrimarySuffix() throws ParseException {
1861
1862 SimpleNode jjtn000 = new SimpleNode(JJTPRIMARYSUFFIX);
1863 boolean jjtc000 = true;
1864 jjtree.openNodeScope(jjtn000);Token tok;
1865 try {
1866 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1867 case DOT:
1868 tok = jj_consume_token(DOT);
1869 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1870 case THIS:
1871 tok = jj_consume_token(THIS);
1872 jjtree.closeNodeScope(jjtn000, true);
1873 jjtc000 = false;
1874 jjtn000.setAttribute("token", tok);
1875 break;
1876 case SUPER:
1877 tok = jj_consume_token(SUPER);
1878 jjtree.closeNodeScope(jjtn000, true);
1879 jjtc000 = false;
1880 jjtn000.setAttribute("token", tok);
1881 break;
1882 case NEW:
1883 AllocationExpression();
1884 break;
1885 case IDENTIFIER:
1886 case LT:
1887 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1888 case LT:
1889 ReferenceTypeList();
1890 break;
1891 default:
1892 jj_la1[45] = jj_gen;
1893 ;
1894 }
1895 tok = jj_consume_token(IDENTIFIER);
1896 jjtree.closeNodeScope(jjtn000, true);
1897 jjtc000 = false;
1898 jjtn000.setAttribute("token", tok);
1899 break;
1900 default:
1901 jj_la1[46] = jj_gen;
1902 jj_consume_token(-1);
1903 throw new ParseException();
1904 }
1905 break;
1906 case LBRACKET:
1907 tok = jj_consume_token(LBRACKET);
1908 jjtn000.setAttribute("token", tok);
1909 Expression();
1910 tok = jj_consume_token(RBRACKET);
1911 break;
1912 case LPAREN:
1913 Arguments();
1914 break;
1915 case LT:
1916 ReferenceTypeList();
1917 break;
1918 default:
1919 jj_la1[47] = jj_gen;
1920 jj_consume_token(-1);
1921 throw new ParseException();
1922 }
1923 } catch (Throwable jjte000) {
1924 if (jjtc000) {
1925 jjtree.clearNodeScope(jjtn000);
1926 jjtc000 = false;
1927 } else {
1928 jjtree.popNode();
1929 }
1930 if (jjte000 instanceof RuntimeException ) {
1931 {if (true) throw (RuntimeException )jjte000;}
1932 }
1933 if (jjte000 instanceof ParseException) {
1934 {if (true) throw (ParseException)jjte000;}
1935 }
1936 {if (true) throw (Error )jjte000;}
1937 } finally {
1938 if (jjtc000) {
1939 jjtree.closeNodeScope(jjtn000, true);
1940 }
1941 }
1942 }
1943
1944 final public void Literal() throws ParseException {
1945
1946 SimpleNode jjtn000 = new SimpleNode(JJTLITERAL);
1947 boolean jjtc000 = true;
1948 jjtree.openNodeScope(jjtn000);Token tok = null;
1949 try {
1950 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1951 case INTEGER_LITERAL:
1952 tok = jj_consume_token(INTEGER_LITERAL);
1953 break;
1954 case FLOATING_POINT_LITERAL:
1955 tok = jj_consume_token(FLOATING_POINT_LITERAL);
1956 break;
1957 case CHARACTER_LITERAL:
1958 tok = jj_consume_token(CHARACTER_LITERAL);
1959 break;
1960 case STRING_LITERAL:
1961 tok = jj_consume_token(STRING_LITERAL);
1962 break;
1963 case FALSE:
1964 case TRUE:
1965 BooleanLiteral();
1966 break;
1967 case NULL:
1968 NullLiteral();
1969 break;
1970 default:
1971 jj_la1[48] = jj_gen;
1972 jj_consume_token(-1);
1973 throw new ParseException();
1974 }
1975 jjtree.closeNodeScope(jjtn000, true);
1976 jjtc000 = false;
1977 if (tok != null) jjtn000.setAttribute("token", tok);
1978 } catch (Throwable jjte000) {
1979 if (jjtc000) {
1980 jjtree.clearNodeScope(jjtn000);
1981 jjtc000 = false;
1982 } else {
1983 jjtree.popNode();
1984 }
1985 if (jjte000 instanceof RuntimeException ) {
1986 {if (true) throw (RuntimeException )jjte000;}
1987 }
1988 if (jjte000 instanceof ParseException) {
1989 {if (true) throw (ParseException)jjte000;}
1990 }
1991 {if (true) throw (Error )jjte000;}
1992 } finally {
1993 if (jjtc000) {
1994 jjtree.closeNodeScope(jjtn000, true);
1995 }
1996 }
1997 }
1998
1999 final public void BooleanLiteral() throws ParseException {
2000
2001 SimpleNode jjtn000 = new SimpleNode(JJTBOOLEANLITERAL);
2002 boolean jjtc000 = true;
2003 jjtree.openNodeScope(jjtn000);Token tok;
2004 try {
2005 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2006 case TRUE:
2007 tok = jj_consume_token(TRUE);
2008 break;
2009 case FALSE:
2010 tok = jj_consume_token(FALSE);
2011 break;
2012 default:
2013 jj_la1[49] = jj_gen;
2014 jj_consume_token(-1);
2015 throw new ParseException();
2016 }
2017 jjtree.closeNodeScope(jjtn000, true);
2018 jjtc000 = false;
2019 jjtn000.setAttribute("token", tok);
2020 } finally {
2021 if (jjtc000) {
2022 jjtree.closeNodeScope(jjtn000, true);
2023 }
2024 }
2025 }
2026
2027 final public void NullLiteral() throws ParseException {
2028
2029 SimpleNode jjtn000 = new SimpleNode(JJTNULLLITERAL);
2030 boolean jjtc000 = true;
2031 jjtree.openNodeScope(jjtn000);
2032 try {
2033 jj_consume_token(NULL);
2034 jjtree.closeNodeScope(jjtn000, true);
2035 jjtc000 = false;
2036 jjtn000.setAttribute("token", token);
2037 } finally {
2038 if (jjtc000) {
2039 jjtree.closeNodeScope(jjtn000, true);
2040 }
2041 }
2042 }
2043
2044 final public void Arguments() throws ParseException {
2045
2046 SimpleNode jjtn000 = new SimpleNode(JJTARGUMENTS);
2047 boolean jjtc000 = true;
2048 jjtree.openNodeScope(jjtn000);
2049 try {
2050 jj_consume_token(LPAREN);
2051 if (jj_2_12(1)) {
2052 ArgumentList();
2053 } else {
2054 ;
2055 }
2056 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2057 case COMMA:
2058 jj_consume_token(COMMA);
2059 break;
2060 default:
2061 jj_la1[50] = jj_gen;
2062 ;
2063 }
2064 jj_consume_token(RPAREN);
2065 } catch (Throwable jjte000) {
2066 if (jjtc000) {
2067 jjtree.clearNodeScope(jjtn000);
2068 jjtc000 = false;
2069 } else {
2070 jjtree.popNode();
2071 }
2072 if (jjte000 instanceof RuntimeException ) {
2073 {if (true) throw (RuntimeException )jjte000;}
2074 }
2075 if (jjte000 instanceof ParseException) {
2076 {if (true) throw (ParseException)jjte000;}
2077 }
2078 {if (true) throw (Error )jjte000;}
2079 } finally {
2080 if (jjtc000) {
2081 jjtree.closeNodeScope(jjtn000, true);
2082 }
2083 }
2084 }
2085
2086 final public void ArgumentList() throws ParseException {
2087
2088 SimpleNode jjtn000 = new SimpleNode(JJTARGUMENTLIST);
2089 boolean jjtc000 = true;
2090 jjtree.openNodeScope(jjtn000);
2091 try {
2092 Expression();
2093 label_20:
2094 while (true) {
2095 if (expressionLookahead()) {
2096 ;
2097 } else {
2098 break label_20;
2099 }
2100 jj_consume_token(COMMA);
2101 Expression();
2102 }
2103 } catch (Throwable jjte000) {
2104 if (jjtc000) {
2105 jjtree.clearNodeScope(jjtn000);
2106 jjtc000 = false;
2107 } else {
2108 jjtree.popNode();
2109 }
2110 if (jjte000 instanceof RuntimeException ) {
2111 {if (true) throw (RuntimeException )jjte000;}
2112 }
2113 if (jjte000 instanceof ParseException) {
2114 {if (true) throw (ParseException)jjte000;}
2115 }
2116 {if (true) throw (Error )jjte000;}
2117 } finally {
2118 if (jjtc000) {
2119 jjtree.closeNodeScope(jjtn000, true);
2120 }
2121 }
2122 }
2123
2124 final public void AllocationExpression() throws ParseException {
2125
2126 SimpleNode jjtn000 = new SimpleNode(JJTALLOCATIONEXPRESSION);
2127 boolean jjtc000 = true;
2128 jjtree.openNodeScope(jjtn000);
2129 try {
2130 jj_consume_token(NEW);
2131 if (jj_2_13(2147483647)) {
2132 ClassOrInterfaceType();
2133 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2134 case LBRACKET:
2135 ArrayDimsAndInits();
2136 break;
2137 case LPAREN:
2138 Arguments();
2139 break;
2140 default:
2141 jj_la1[51] = jj_gen;
2142 jj_consume_token(-1);
2143 throw new ParseException();
2144 }
2145 } else {
2146 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2147 case BOOLEAN:
2148 case BYTE:
2149 case CHAR:
2150 case DOUBLE:
2151 case FLOAT:
2152 case INT:
2153 case LONG:
2154 case SHORT:
2155 PrimitiveType();
2156 ArrayDimsAndInits();
2157 break;
2158 default:
2159 jj_la1[52] = jj_gen;
2160 jj_consume_token(-1);
2161 throw new ParseException();
2162 }
2163 }
2164 } catch (Throwable jjte000) {
2165 if (jjtc000) {
2166 jjtree.clearNodeScope(jjtn000);
2167 jjtc000 = false;
2168 } else {
2169 jjtree.popNode();
2170 }
2171 if (jjte000 instanceof RuntimeException ) {
2172 {if (true) throw (RuntimeException )jjte000;}
2173 }
2174 if (jjte000 instanceof ParseException) {
2175 {if (true) throw (ParseException)jjte000;}
2176 }
2177 {if (true) throw (Error )jjte000;}
2178 } finally {
2179 if (jjtc000) {
2180 jjtree.closeNodeScope(jjtn000, true);
2181 }
2182 }
2183 }
2184
2185
2189 final public void ArrayDimsAndInits() throws ParseException {
2190
2191 SimpleNode jjtn000 = new SimpleNode(JJTARRAYDIMSANDINITS);
2192 boolean jjtc000 = true;
2193 jjtree.openNodeScope(jjtn000);int arrayCount = 0;
2194 try {
2195 if (jj_2_16(2)) {
2196 label_21:
2197 while (true) {
2198 jj_consume_token(LBRACKET);
2199 Expression();
2200 jj_consume_token(RBRACKET);
2201 arrayCount++;
2202 if (jj_2_14(2)) {
2203 ;
2204 } else {
2205 break label_21;
2206 }
2207 }
2208 label_22:
2209 while (true) {
2210 if (jj_2_15(4)) {
2211 ;
2212 } else {
2213 break label_22;
2214 }
2215 jj_consume_token(LBRACKET);
2216 jj_consume_token(RBRACKET);
2217 arrayCount++;
2218 }
2219 } else {
2220 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2221 case LBRACKET:
2222 label_23:
2223 while (true) {
2224 jj_consume_token(LBRACKET);
2225 jj_consume_token(RBRACKET);
2226 arrayCount++;
2227 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2228 case LBRACKET:
2229 ;
2230 break;
2231 default:
2232 jj_la1[53] = jj_gen;
2233 break label_23;
2234 }
2235 }
2236 ArrayInitializer();
2237 jjtn000.setAttribute("initializers", Boolean.TRUE);
2238 break;
2239 default:
2240 jj_la1[54] = jj_gen;
2241 jj_consume_token(-1);
2242 throw new ParseException();
2243 }
2244 }
2245 jjtree.closeNodeScope(jjtn000, true);
2246 jjtc000 = false;
2247 jjtn000.setAttribute("dimensions", new Integer (arrayCount));
2248 } catch (Throwable jjte000) {
2249 if (jjtc000) {
2250 jjtree.clearNodeScope(jjtn000);
2251 jjtc000 = false;
2252 } else {
2253 jjtree.popNode();
2254 }
2255 if (jjte000 instanceof RuntimeException ) {
2256 {if (true) throw (RuntimeException )jjte000;}
2257 }
2258 if (jjte000 instanceof ParseException) {
2259 {if (true) throw (ParseException)jjte000;}
2260 }
2261 {if (true) throw (Error )jjte000;}
2262 } finally {
2263 if (jjtc000) {
2264 jjtree.closeNodeScope(jjtn000, true);
2265 }
2266 }
2267 }
2268
2269 final private boolean jj_2_1(int xla) {
2270 jj_la = xla; jj_lastpos = jj_scanpos = token;
2271 try { return !jj_3_1(); }
2272 catch(LookaheadSuccess ls) { return true; }
2273 finally { jj_save(0, xla); }
2274 }
2275
2276 final private boolean jj_2_2(int xla) {
2277 jj_la = xla; jj_lastpos = jj_scanpos = token;
2278 try { return !jj_3_2(); }
2279 catch(LookaheadSuccess ls) { return true; }
2280 finally { jj_save(1, xla); }
2281 }
2282
2283 final private boolean jj_2_3(int xla) {
2284 jj_la = xla; jj_lastpos = jj_scanpos = token;
2285 try { return !jj_3_3(); }
2286 catch(LookaheadSuccess ls) { return true; }
2287 finally { jj_save(2, xla); }
2288 }
2289
2290 final private boolean jj_2_4(int xla) {
2291 jj_la = xla; jj_lastpos = jj_scanpos = token;
2292 try { return !jj_3_4(); }
2293 catch(LookaheadSuccess ls) { return true; }
2294 finally { jj_save(3, xla); }
2295 }
2296
2297 final private boolean jj_2_5(int xla) {
2298 jj_la = xla; jj_lastpos = jj_scanpos = token;
2299 try { return !jj_3_5(); }
2300 catch(LookaheadSuccess ls) { return true; }
2301 finally { jj_save(4, xla); }
2302 }
2303
2304 final private boolean jj_2_6(int xla) {
2305 jj_la = xla; jj_lastpos = jj_scanpos = token;
2306 try { return !jj_3_6(); }
2307 catch(LookaheadSuccess ls) { return true; }
2308 finally { jj_save(5, xla); }
2309 }
2310
2311 final private boolean jj_2_7(int xla) {
2312 jj_la = xla; jj_lastpos = jj_scanpos = token;
2313 try { return !jj_3_7(); }
2314 catch(LookaheadSuccess ls) { return true; }
2315 finally { jj_save(6, xla); }
2316 }
2317
2318 final private boolean jj_2_8(int xla) {
2319 jj_la = xla; jj_lastpos = jj_scanpos = token;
2320 try { return !jj_3_8(); }
2321 catch(LookaheadSuccess ls) { return true; }
2322 finally { jj_save(7, xla); }
2323 }
2324
2325 final private boolean jj_2_9(int xla) {
2326 jj_la = xla; jj_lastpos = jj_scanpos = token;
2327 try { return !jj_3_9(); }
2328 catch(LookaheadSuccess ls) { return true; }
2329 finally { jj_save(8, xla); }
2330 }
2331
2332 final private boolean jj_2_10(int xla) {
2333 jj_la = xla; jj_lastpos = jj_scanpos = token;
2334 try { return !jj_3_10(); }
2335 catch(LookaheadSuccess ls) { return true; }
2336 finally { jj_save(9, xla); }
2337 }
2338
2339 final private boolean jj_2_11(int xla) {
2340 jj_la = xla; jj_lastpos = jj_scanpos = token;
2341 try { return !jj_3_11(); }
2342 catch(LookaheadSuccess ls) { return true; }
2343 finally { jj_save(10, xla); }
2344 }
2345
2346 final private boolean jj_2_12(int xla) {
2347 jj_la = xla; jj_lastpos = jj_scanpos = token;
2348 try { return !jj_3_12(); }
2349 catch(LookaheadSuccess ls) { return true; }
2350 finally { jj_save(11, xla); }
2351 }
2352
2353 final private boolean jj_2_13(int xla) {
2354 jj_la = xla; jj_lastpos = jj_scanpos = token;
2355 try { return !jj_3_13(); }
2356 catch(LookaheadSuccess ls) { return true; }
2357 finally { jj_save(12, xla); }
2358 }
2359
2360 final private boolean jj_2_14(int xla) {
2361 jj_la = xla; jj_lastpos = jj_scanpos = token;
2362 try { return !jj_3_14(); }
2363 catch(LookaheadSuccess ls) { return true; }
2364 finally { jj_save(13, xla); }
2365 }
2366
2367 final private boolean jj_2_15(int xla) {
2368 jj_la = xla; jj_lastpos = jj_scanpos = token;
2369 try { return !jj_3_15(); }
2370 catch(LookaheadSuccess ls) { return true; }
2371 finally { jj_save(14, xla); }
2372 }
2373
2374 final private boolean jj_2_16(int xla) {
2375 jj_la = xla; jj_lastpos = jj_scanpos = token;
2376 try { return !jj_3_16(); }
2377 catch(LookaheadSuccess ls) { return true; }
2378 finally { jj_save(15, xla); }
2379 }
2380
2381 final private boolean jj_3_3() {
2382 if (jj_3R_25()) return true;
2383 return false;
2384 }
2385
2386 final private boolean jj_3R_100() {
2387 if (jj_3R_101()) return true;
2388 return false;
2389 }
2390
2391 final private boolean jj_3R_93() {
2392 if (jj_3R_96()) return true;
2393 return false;
2394 }
2395
2396 final private boolean jj_3R_92() {
2397 if (jj_3R_95()) return true;
2398 return false;
2399 }
2400
2401 final private boolean jj_3R_33() {
2402 if (jj_scan_token(DOT)) return true;
2403 Token xsp;
2404 xsp = jj_scanpos;
2405 if (jj_3R_48()) jj_scanpos = xsp;
2406 if (jj_scan_token(IDENTIFIER)) return true;
2407 return false;
2408 }
2409
2410 final private boolean jj_3R_56() {
2411 if (jj_scan_token(LBRACE)) return true;
2412 return false;
2413 }
2414
2415 final private boolean jj_3R_87() {
2416 Token xsp;
2417 xsp = jj_scanpos;
2418 if (jj_scan_token(71)) {
2419 jj_scanpos = xsp;
2420 if (jj_scan_token(75)) {
2421 jj_scanpos = xsp;
2422 if (jj_scan_token(77)) {
2423 jj_scanpos = xsp;
2424 if (jj_scan_token(78)) {
2425 jj_scanpos = xsp;
2426 if (jj_3R_92()) {
2427 jj_scanpos = xsp;
2428 if (jj_3R_93()) return true;
2429 }
2430 }
2431 }
2432 }
2433 }
2434 return false;
2435 }
2436
2437 final private boolean jj_3_1() {
2438 if (jj_3R_24()) return true;
2439 return false;
2440 }
2441
2442 final private boolean jj_3R_40() {
2443 if (jj_3R_56()) return true;
2444 return false;
2445 }
2446
2447 final private boolean jj_3R_25() {
2448 Token xsp;
2449 xsp = jj_scanpos;
2450 if (jj_3R_40()) {
2451 jj_scanpos = xsp;
2452 if (jj_3_1()) return true;
2453 }
2454 return false;
2455 }
2456
2457 final private boolean jj_3R_24() {
2458 if (jj_3R_39()) return true;
2459 return false;
2460 }
2461
2462 final private boolean jj_3R_52() {
2463 if (jj_scan_token(IDENTIFIER)) return true;
2464 return false;
2465 }
2466
2467 final private boolean jj_3R_32() {
2468 if (jj_scan_token(DOT)) return true;
2469 if (jj_scan_token(LT)) return true;
2470 return false;
2471 }
2472
2473 final private boolean jj_3R_99() {
2474 if (jj_3R_100()) return true;
2475 return false;
2476 }
2477
2478 final private boolean jj_3_7() {
2479 if (jj_scan_token(DOT)) return true;
2480 if (jj_scan_token(IDENTIFIER)) return true;
2481 return false;
2482 }
2483
2484 final private boolean jj_3R_85() {
2485 if (jj_scan_token(SUPER)) return true;
2486 return false;
2487 }
2488
2489 final private boolean jj_3R_44() {
2490 if (jj_3R_26()) return true;
2491 return false;
2492 }
2493
2494 final private boolean jj_3R_84() {
2495 if (jj_scan_token(EXTENDS)) return true;
2496 return false;
2497 }
2498
2499 final private boolean jj_3R_67() {
2500 if (jj_3R_66()) return true;
2501 return false;
2502 }
2503
2504 final private boolean jj_3R_75() {
2505 Token xsp;
2506 xsp = jj_scanpos;
2507 if (jj_3R_84()) {
2508 jj_scanpos = xsp;
2509 if (jj_3R_85()) return true;
2510 }
2511 if (jj_3R_26()) return true;
2512 return false;
2513 }
2514
2515 final private boolean jj_3R_54() {
2516 if (jj_scan_token(DOT)) return true;
2517 if (jj_3R_52()) return true;
2518 Token xsp;
2519 xsp = jj_scanpos;
2520 if (jj_3R_67()) jj_scanpos = xsp;
2521 return false;
2522 }
2523
2524 final private boolean jj_3R_53() {
2525 if (jj_3R_66()) return true;
2526 return false;
2527 }
2528
2529 final private boolean jj_3R_43() {
2530 if (jj_scan_token(HOOK)) return true;
2531 Token xsp;
2532 xsp = jj_scanpos;
2533 if (jj_3R_75()) jj_scanpos = xsp;
2534 return false;
2535 }
2536
2537 final private boolean jj_3R_38() {
2538 if (jj_3R_52()) return true;
2539 Token xsp;
2540 xsp = jj_scanpos;
2541 if (jj_3R_53()) jj_scanpos = xsp;
2542 while (true) {
2543 xsp = jj_scanpos;
2544 if (jj_3R_54()) { jj_scanpos = xsp; break; }
2545 }
2546 return false;
2547 }
2548
2549 final private boolean jj_3_11() {
2550 if (jj_3R_36()) return true;
2551 if (jj_scan_token(DOT)) return true;
2552 if (jj_scan_token(CLASS)) return true;
2553 return false;
2554 }
2555
2556 final private boolean jj_3R_27() {
2557 Token xsp;
2558 xsp = jj_scanpos;
2559 if (jj_3R_43()) {
2560 jj_scanpos = xsp;
2561 if (jj_3R_44()) return true;
2562 }
2563 return false;
2564 }
2565
2566 final private boolean jj_3R_98() {
2567 if (jj_3R_99()) return true;
2568 return false;
2569 }
2570
2571 final private boolean jj_3R_31() {
2572 if (jj_scan_token(DOT)) return true;
2573 if (jj_scan_token(NEW)) return true;
2574 return false;
2575 }
2576
2577 final private boolean jj_3R_83() {
2578 if (jj_3R_90()) return true;
2579 return false;
2580 }
2581
2582 final private boolean jj_3_6() {
2583 if (jj_scan_token(DOT)) return true;
2584 if (jj_scan_token(IDENTIFIER)) return true;
2585 return false;
2586 }
2587
2588 final private boolean jj_3R_82() {
2589 if (jj_3R_36()) return true;
2590 return false;
2591 }
2592
2593 final private boolean jj_3R_81() {
2594 if (jj_3R_89()) return true;
2595 return false;
2596 }
2597
2598 final private boolean jj_3R_64() {
2599 if (jj_scan_token(RUNSIGNEDSHIFT)) return true;
2600 return false;
2601 }
2602
2603 final private boolean jj_3R_90() {
2604 if (jj_scan_token(IDENTIFIER)) return true;
2605 return false;
2606 }
2607
2608 final private boolean jj_3R_80() {
2609 if (jj_scan_token(LPAREN)) return true;
2610 return false;
2611 }
2612
2613 final private boolean jj_3R_63() {
2614 if (jj_scan_token(RSIGNEDSHIFT)) return true;
2615 return false;
2616 }
2617
2618 final private boolean jj_3R_35() {
2619 if (jj_scan_token(IDENTIFIER)) return true;
2620 if (jj_scan_token(DOT)) return true;
2621 return false;
2622 }
2623
2624 final private boolean jj_3R_30() {
2625 if (jj_scan_token(DOT)) return true;
2626 if (jj_scan_token(SUPER)) return true;
2627 return false;
2628 }
2629
2630 final private boolean jj_3_10() {
2631 Token xsp;
2632 while (true) {
2633 xsp = jj_scanpos;
2634 if (jj_3R_35()) { jj_scanpos = xsp; break; }
2635 }
2636 if (jj_scan_token(SUPER)) return true;
2637 if (jj_scan_token(DOT)) return true;
2638 return false;
2639 }
2640
2641 final private boolean jj_3R_97() {
2642 if (jj_3R_98()) return true;
2643 return false;
2644 }
2645
2646 final private boolean jj_3R_88() {
2647 if (jj_scan_token(IDENTIFIER)) return true;
2648 return false;
2649 }
2650
2651 final private boolean jj_3R_62() {
2652 if (jj_scan_token(COMMA)) return true;
2653 if (jj_3R_27()) return true;
2654 return false;
2655 }
2656
2657 final private boolean jj_3R_51() {
2658 if (jj_3R_65()) return true;
2659 return false;
2660 }
2661
2662 final private boolean jj_3R_79() {
2663 Token xsp;
2664 while (true) {
2665 xsp = jj_scanpos;
2666 if (jj_3R_88()) { jj_scanpos = xsp; break; }
2667 }
2668 if (jj_scan_token(SUPER)) return true;
2669 return false;
2670 }
2671
2672 final private boolean jj_3R_36() {
2673 Token xsp;
2674 xsp = jj_scanpos;
2675 if (jj_3R_50()) {
2676 jj_scanpos = xsp;
2677 if (jj_3R_51()) return true;
2678 }
2679 return false;
2680 }
2681
2682 final private boolean jj_3R_50() {
2683 if (jj_scan_token(VOID)) return true;
2684 return false;
2685 }
2686
2687 final private boolean jj_3R_78() {
2688 if (jj_scan_token(THIS)) return true;
2689 return false;
2690 }
2691
2692 final private boolean jj_3R_29() {
2693 if (jj_scan_token(DOT)) return true;
2694 if (jj_scan_token(THIS)) return true;
2695 return false;
2696 }
2697
2698 final private boolean jj_3_9() {
2699 Token xsp;
2700 xsp = jj_scanpos;
2701 if (jj_3R_29()) {
2702 jj_scanpos = xsp;
2703 if (jj_3R_30()) {
2704 jj_scanpos = xsp;
2705 if (jj_3R_31()) {
2706 jj_scanpos = xsp;
2707 if (jj_scan_token(82)) {
2708 jj_scanpos = xsp;
2709 if (jj_scan_token(86)) {
2710 jj_scanpos = xsp;
2711 if (jj_3R_32()) {
2712 jj_scanpos = xsp;
2713 if (jj_3R_33()) {
2714 jj_scanpos = xsp;
2715 if (jj_3R_34()) return true;
2716 }
2717 }
2718 }
2719 }
2720 }
2721 }
2722 }
2723 return false;
2724 }
2725
2726 final private boolean jj_3R_77() {
2727 if (jj_3R_87()) return true;
2728 return false;
2729 }
2730
2731 final private boolean jj_3R_49() {
2732 if (jj_scan_token(LT)) return true;
2733 if (jj_3R_27()) return true;
2734 Token xsp;
2735 while (true) {
2736 xsp = jj_scanpos;
2737 if (jj_3R_62()) { jj_scanpos = xsp; break; }
2738 }
2739 xsp = jj_scanpos;
2740 if (jj_scan_token(93)) {
2741 jj_scanpos = xsp;
2742 if (jj_3R_63()) {
2743 jj_scanpos = xsp;
2744 if (jj_3R_64()) return true;
2745 }
2746 }
2747 return false;
2748 }
2749
2750 final private boolean jj_3R_94() {
2751 if (jj_3R_97()) return true;
2752 return false;
2753 }
2754
2755 final private boolean jj_3R_74() {
2756 Token xsp;
2757 xsp = jj_scanpos;
2758 if (jj_3R_77()) {
2759 jj_scanpos = xsp;
2760 if (jj_3R_78()) {
2761 jj_scanpos = xsp;
2762 if (jj_3R_79()) {
2763 jj_scanpos = xsp;
2764 if (jj_3R_80()) {
2765 jj_scanpos = xsp;
2766 if (jj_3R_81()) {
2767 jj_scanpos = xsp;
2768 if (jj_3R_82()) {
2769 jj_scanpos = xsp;
2770 if (jj_3R_83()) return true;
2771 }
2772 }
2773 }
2774 }
2775 }
2776 }
2777 return false;
2778 }
2779
2780 final private boolean jj_3R_91() {
2781 if (jj_3R_94()) return true;
2782 return false;
2783 }
2784
2785 final private boolean jj_3R_69() {
2786 if (jj_3R_74()) return true;
2787 return false;
2788 }
2789
2790 final private boolean jj_3R_58() {
2791 Token xsp;
2792 xsp = jj_scanpos;
2793 if (jj_scan_token(20)) {
2794 jj_scanpos = xsp;
2795 if (jj_scan_token(25)) {
2796 jj_scanpos = xsp;
2797 if (jj_scan_token(22)) {
2798 jj_scanpos = xsp;
2799 if (jj_scan_token(56)) {
2800 jj_scanpos = xsp;
2801 if (jj_scan_token(45)) {
2802 jj_scanpos = xsp;
2803 if (jj_scan_token(47)) {
2804 jj_scanpos = xsp;
2805 if (jj_scan_token(38)) {
2806 jj_scanpos = xsp;
2807 if (jj_scan_token(31)) return true;
2808 }
2809 }
2810 }
2811 }
2812 }
2813 }
2814 }
2815 return false;
2816 }
2817
2818 final private boolean jj_3R_60() {
2819 if (jj_scan_token(LPAREN)) return true;
2820 return false;
2821 }
2822
2823 final private boolean jj_3R_86() {
2824 if (jj_3R_91()) return true;
2825 return false;
2826 }
2827
2828 final private boolean jj_3R_72() {
2829 if (jj_scan_token(RUNSIGNEDSHIFT)) return true;
2830 return false;
2831 }
2832
2833 final private boolean jj_3R_61() {
2834 if (jj_3R_69()) return true;
2835 return false;
2836 }
2837
2838 final private boolean jj_3R_71() {
2839 if (jj_scan_token(RSIGNEDSHIFT)) return true;
2840 return false;
2841 }
2842
2843 final private boolean jj_3_15() {
2844 if (jj_scan_token(LBRACKET)) return true;
2845 if (jj_scan_token(RBRACKET)) return true;
2846 return false;
2847 }
2848
2849 final private boolean jj_3R_76() {
2850 if (jj_3R_86()) return true;
2851 return false;
2852 }
2853
2854 final private boolean jj_3R_47() {
2855 if (jj_3R_61()) return true;
2856 return false;
2857 }
2858
2859 final private boolean jj_3_14() {
2860 if (jj_scan_token(LBRACKET)) return true;
2861 if (jj_3R_24()) return true;
2862 return false;
2863 }
2864
2865 final private boolean jj_3_5() {
2866 if (jj_scan_token(COMMA)) return true;
2867 if (jj_3R_27()) return true;
2868 return false;
2869 }
2870
2871 final private boolean jj_3_16() {
2872 Token xsp;
2873 if (jj_3_14()) return true;
2874 while (true) {
2875 xsp = jj_scanpos;
2876 if (jj_3_14()) { jj_scanpos = xsp; break; }
2877 }
2878 return false;
2879 }
2880
2881 final private boolean jj_3R_46() {
2882 Token xsp;
2883 xsp = jj_scanpos;
2884 if (jj_scan_token(96)) {
2885 jj_scanpos = xsp;
2886 if (jj_scan_token(95)) return true;
2887 }
2888 return false;
2889 }
2890
2891 final private boolean jj_3R_45() {
2892 if (jj_3R_60()) return true;
2893 return false;
2894 }
2895
2896 final private boolean jj_3R_73() {
2897 if (jj_3R_76()) return true;
2898 return false;
2899 }
2900
2901 final private boolean jj_3R_66() {
2902 if (jj_scan_token(LT)) return true;
2903 if (jj_3R_27()) return true;
2904 Token xsp;
2905 while (true) {
2906 xsp = jj_scanpos;
2907 if (jj_3_5()) { jj_scanpos = xsp; break; }
2908 }
2909 xsp = jj_scanpos;
2910 if (jj_scan_token(93)) {
2911 jj_scanpos = xsp;
2912 if (jj_3R_71()) {
2913 jj_scanpos = xsp;
2914 if (jj_3R_72()) return true;
2915 }
2916 }
2917 return false;
2918 }
2919
2920 final private boolean jj_3R_28() {
2921 Token xsp;
2922 xsp = jj_scanpos;
2923 lookingAhead = true;
2924 jj_semLA = castLookahead();
2925 lookingAhead = false;
2926 if (!jj_semLA || jj_3R_45()) {
2927 jj_scanpos = xsp;
2928 if (jj_3R_46()) {
2929 jj_scanpos = xsp;
2930 if (jj_3R_47()) return true;
2931 }
2932 }
2933 return false;
2934 }
2935
2936 final private boolean jj_3R_106() {
2937 if (jj_scan_token(DECR)) return true;
2938 return false;
2939 }
2940
2941 final private boolean jj_3_13() {
2942 if (jj_3R_38()) return true;
2943 return false;
2944 }
2945
2946 final private boolean jj_3R_59() {
2947 if (jj_scan_token(LBRACKET)) return true;
2948 if (jj_scan_token(RBRACKET)) return true;
2949 return false;
2950 }
2951
2952 final private boolean jj_3R_68() {
2953 if (jj_3R_73()) return true;
2954 return false;
2955 }
2956
2957 final private boolean jj_3R_105() {
2958 if (jj_scan_token(INCR)) return true;
2959 return false;
2960 }
2961
2962 final private boolean jj_3R_42() {
2963 if (jj_3R_58()) return true;
2964 Token xsp;
2965 if (jj_3R_59()) return true;
2966 while (true) {
2967 xsp = jj_scanpos;
2968 if (jj_3R_59()) { jj_scanpos = xsp; break; }
2969 }
2970 return false;
2971 }
2972
2973 final private boolean jj_3R_57() {
2974 if (jj_scan_token(LBRACKET)) return true;
2975 if (jj_scan_token(RBRACKET)) return true;
2976 return false;
2977 }
2978
2979 final private boolean jj_3R_34() {
2980 if (jj_3R_49()) return true;
2981 return false;
2982 }
2983
2984 final private boolean jj_3R_89() {
2985 if (jj_scan_token(NEW)) return true;
2986 return false;
2987 }
2988
2989 final private boolean jj_3_8() {
2990 if (jj_3R_28()) return true;
2991 return false;
2992 }
2993
2994 final private boolean jj_3R_41() {
2995 if (jj_3R_38()) return true;
2996 Token xsp;
2997 while (true) {
2998 xsp = jj_scanpos;
2999 if (jj_3R_57()) { jj_scanpos = xsp; break; }
3000 }
3001 return false;
3002 }
3003
3004 final private boolean jj_3R_26() {
3005 Token xsp;
3006 xsp = jj_scanpos;
3007 if (jj_3R_41()) {
3008 jj_scanpos = xsp;
3009 if (jj_3R_42()) return true;
3010 }
3011 return false;
3012 }
3013
3014 final private boolean jj_3R_55() {
3015 if (jj_3R_68()) return true;
3016 return false;
3017 }
3018
3019 final private boolean jj_3R_104() {
3020 if (jj_3R_106()) return true;
3021 return false;
3022 }
3023
3024 final private boolean jj_3R_103() {
3025 if (jj_3R_105()) return true;
3026 return false;
3027 }
3028
3029 final private boolean jj_3R_37() {
3030 if (jj_3R_24()) return true;
3031 return false;
3032 }
3033
3034 final private boolean jj_3R_70() {
3035 if (jj_3R_58()) return true;
3036 return false;
3037 }
3038
3039 final private boolean jj_3_12() {
3040 if (jj_3R_37()) return true;
3041 return false;
3042 }
3043
3044 final private boolean jj_3R_102() {
3045 Token xsp;
3046 xsp = jj_scanpos;
3047 if (jj_scan_token(107)) {
3048 jj_scanpos = xsp;
3049 if (jj_scan_token(108)) return true;
3050 }
3051 return false;
3052 }
3053
3054 final private boolean jj_3_4() {
3055 if (jj_3R_26()) return true;
3056 return false;
3057 }
3058
3059 final private boolean jj_3R_101() {
3060 Token xsp;
3061 xsp = jj_scanpos;
3062 if (jj_3R_102()) {
3063 jj_scanpos = xsp;
3064 if (jj_3R_103()) {
3065 jj_scanpos = xsp;
3066 if (jj_3R_104()) {
3067 jj_scanpos = xsp;
3068 if (jj_3_8()) return true;
3069 }
3070 }
3071 }
3072 return false;
3073 }
3074
3075 final private boolean jj_3R_65() {
3076 Token xsp;
3077 xsp = jj_scanpos;
3078 if (jj_3_4()) {
3079 jj_scanpos = xsp;
3080 if (jj_3R_70()) return true;
3081 }
3082 return false;
3083 }
3084
3085 final private boolean jj_3R_39() {
3086 if (jj_3R_55()) return true;
3087 return false;
3088 }
3089
3090 final private boolean jj_3R_96() {
3091 if (jj_scan_token(NULL)) return true;
3092 return false;
3093 }
3094
3095 final private boolean jj_3R_95() {
3096 Token xsp;
3097 xsp = jj_scanpos;
3098 if (jj_scan_token(66)) {
3099 jj_scanpos = xsp;
3100 if (jj_scan_token(35)) return true;
3101 }
3102 return false;
3103 }
3104
3105 final private boolean jj_3_2() {
3106 if (jj_scan_token(COMMA)) return true;
3107 if (jj_3R_25()) return true;
3108 return false;
3109 }
3110
3111 final private boolean jj_3R_48() {
3112 if (jj_3R_49()) return true;
3113 return false;
3114 }
3115
3116 public JavaParserTokenManager token_source;
3117 SimpleCharStream jj_input_stream;
3118 public Token token, jj_nt;
3119 private int jj_ntk;
3120 private Token jj_scanpos, jj_lastpos;
3121 private int jj_la;
3122 public boolean lookingAhead = false;
3123 private boolean jj_semLA;
3124 private int jj_gen;
3125 final private int[] jj_la1 = new int[55];
3126 static private int[] jj_la1_0;
3127 static private int[] jj_la1_1;
3128 static private int[] jj_la1_2;
3129 static private int[] jj_la1_3;
3130 static private int[] jj_la1_4;
3131 static {
3132 jj_la1_0();
3133 jj_la1_1();
3134 jj_la1_2();
3135 jj_la1_3();
3136 jj_la1_4();
3137 }
3138 private static void jj_la1_0() {
3139 jj_la1_0 = new int[] {0x0,0x0,0x0,0x0,0x82500000,0x0,0x0,0x82500000,0x0,0x0,0x82500000,0x0,0x82500000,0x82500000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x82500000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x82500000,0x0,0x0,};
3140 }
3141 private static void jj_la1_1() {
3142 jj_la1_1 = new int[] {0x0,0x0,0x8000004,0x8000004,0x100a040,0x0,0x0,0x100a040,0x0,0x0,0x100a040,0x0,0x100a040,0x100a040,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x4906a048,0x0,0x0,0x0,0x40040008,0x20000,0x0,0x0,0x48020000,0x0,0x40008,0x8,0x0,0x0,0x100a040,0x0,0x0,};
3143 }
3144 private static void jj_la1_2() {
3145 jj_la1_2 = new int[] {0x2000000,0x20000000,0x0,0x0,0x8000,0x100000,0x2000000,0x0,0x400000,0x400000,0x8000,0x20000000,0x0,0x8010,0x40000000,0x40000000,0x10000000,0x10000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x60000000,0x60000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x80000000,0x8004e894,0x0,0x0,0x8000,0x6884,0x40000,0x8000,0x40000000,0x40008000,0x44440000,0x6884,0x4,0x2000000,0x440000,0x0,0x400000,0x400000,};
3146 }
3147 private static void jj_la1_3() {
3148 jj_la1_3 = new int[] {0x0,0x300000,0x0,0x0,0x2,0x0,0x0,0x0,0x0,0x0,0x0,0x300000,0x0,0x0,0x0,0x0,0xffc00000,0xffc00000,0x2,0x80,0x100,0x10000,0x20000,0x8000,0x48,0x48,0x0,0x30,0x30,0x380000,0x380000,0x1800,0x1800,0x46000,0x46000,0x1800,0x1e00,0x1,0x1,0x600,0x600,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,};
3149 }
3150 private static void jj_la1_4() {
3151 jj_la1_4 = new int[] {0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,};
3152 }
3153 final private JJCalls[] jj_2_rtns = new JJCalls[16];
3154 private boolean jj_rescan = false;
3155 private int jj_gc = 0;
3156
3157 public JavaParser(java.io.InputStream stream) {
3158 jj_input_stream = new SimpleCharStream(stream, 1, 1);
3159 token_source = new JavaParserTokenManager(jj_input_stream);
3160 token = new Token();
3161 jj_ntk = -1;
3162 jj_gen = 0;
3163 for (int i = 0; i < 55; i++) jj_la1[i] = -1;
3164 for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
3165 }
3166
3167 public void ReInit(java.io.InputStream stream) {
3168 jj_input_stream.ReInit(stream, 1, 1);
3169 token_source.ReInit(jj_input_stream);
3170 token = new Token();
3171 jj_ntk = -1;
3172 jjtree.reset();
3173 jj_gen = 0;
3174 for (int i = 0; i < 55; i++) jj_la1[i] = -1;
3175 for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
3176 }
3177
3178 public JavaParser(java.io.Reader stream) {
3179 jj_input_stream = new SimpleCharStream(stream, 1, 1);
3180 token_source = new JavaParserTokenManager(jj_input_stream);
3181 token = new Token();
3182 jj_ntk = -1;
3183 jj_gen = 0;
3184 for (int i = 0; i < 55; i++) jj_la1[i] = -1;
3185 for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
3186 }
3187
3188 public void ReInit(java.io.Reader stream) {
3189 jj_input_stream.ReInit(stream, 1, 1);
3190 token_source.ReInit(jj_input_stream);
3191 token = new Token();
3192 jj_ntk = -1;
3193 jjtree.reset();
3194 jj_gen = 0;
3195 for (int i = 0; i < 55; i++) jj_la1[i] = -1;
3196 for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
3197 }
3198
3199 public JavaParser(JavaParserTokenManager tm) {
3200 token_source = tm;
3201 token = new Token();
3202 jj_ntk = -1;
3203 jj_gen = 0;
3204 for (int i = 0; i < 55; i++) jj_la1[i] = -1;
3205 for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
3206 }
3207
3208 public void ReInit(JavaParserTokenManager tm) {
3209 token_source = tm;
3210 token = new Token();
3211 jj_ntk = -1;
3212 jjtree.reset();
3213 jj_gen = 0;
3214 for (int i = 0; i < 55; i++) jj_la1[i] = -1;
3215 for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
3216 }
3217
3218 final private Token jj_consume_token(int kind) throws ParseException {
3219 Token oldToken;
3220 if ((oldToken = token).next != null) token = token.next;
3221 else token = token.next = token_source.getNextToken();
3222 jj_ntk = -1;
3223 if (token.kind == kind) {
3224 jj_gen++;
3225 if (++jj_gc > 100) {
3226 jj_gc = 0;
3227 for (int i = 0; i < jj_2_rtns.length; i++) {
3228 JJCalls c = jj_2_rtns[i];
3229 while (c != null) {
3230 if (c.gen < jj_gen) c.first = null;
3231 c = c.next;
3232 }
3233 }
3234 }
3235 return token;
3236 }
3237 token = oldToken;
3238 jj_kind = kind;
3239 throw generateParseException();
3240 }
3241
3242 static private final class LookaheadSuccess extends java.lang.Error { }
3243 final private LookaheadSuccess jj_ls = new LookaheadSuccess();
3244 final private boolean jj_scan_token(int kind) {
3245 if (jj_scanpos == jj_lastpos) {
3246 jj_la--;
3247 if (jj_scanpos.next == null) {
3248 jj_lastpos = jj_scanpos = jj_scanpos.next = token_source.getNextToken();
3249 } else {
3250 jj_lastpos = jj_scanpos = jj_scanpos.next;
3251 }
3252 } else {
3253 jj_scanpos = jj_scanpos.next;
3254 }
3255 if (jj_rescan) {
3256 int i = 0; Token tok = token;
3257 while (tok != null && tok != jj_scanpos) { i++; tok = tok.next; }
3258 if (tok != null) jj_add_error_token(kind, i);
3259 }
3260 if (jj_scanpos.kind != kind) return true;
3261 if (jj_la == 0 && jj_scanpos == jj_lastpos) throw jj_ls;
3262 return false;
3263 }
3264
3265 final public Token getNextToken() {
3266 if (token.next != null) token = token.next;
3267 else token = token.next = token_source.getNextToken();
3268 jj_ntk = -1;
3269 jj_gen++;
3270 return token;
3271 }
3272
3273 final public Token getToken(int index) {
3274 Token t = lookingAhead ? jj_scanpos : token;
3275 for (int i = 0; i < index; i++) {
3276 if (t.next != null) t = t.next;
3277 else t = t.next = token_source.getNextToken();
3278 }
3279 return t;
3280 }
3281
3282 final private int jj_ntk() {
3283 if ((jj_nt=token.next) == null)
3284 return (jj_ntk = (token.next=token_source.getNextToken()).kind);
3285 else
3286 return (jj_ntk = jj_nt.kind);
3287 }
3288
3289 private java.util.Vector <int[]> jj_expentries = new java.util.Vector <int[]>();
3290 private int[] jj_expentry;
3291 private int jj_kind = -1;
3292 private int[] jj_lasttokens = new int[100];
3293 private int jj_endpos;
3294
3295 private void jj_add_error_token(int kind, int pos) {
3296 if (pos >= 100) return;
3297 if (pos == jj_endpos + 1) {
3298 jj_lasttokens[jj_endpos++] = kind;
3299 } else if (jj_endpos != 0) {
3300 jj_expentry = new int[jj_endpos];
3301 for (int i = 0; i < jj_endpos; i++) {
3302 jj_expentry[i] = jj_lasttokens[i];
3303 }
3304 boolean exists = false;
3305 for (java.util.Enumeration <int[]> e = jj_expentries.elements(); e.hasMoreElements();) {
3306 int[] oldentry = e.nextElement();
3307 if (oldentry.length == jj_expentry.length) {
3308 exists = true;
3309 for (int i = 0; i < jj_expentry.length; i++) {
3310 if (oldentry[i] != jj_expentry[i]) {
3311 exists = false;
3312 break;
3313 }
3314 }
3315 if (exists) break;
3316 }
3317 }
3318 if (!exists) jj_expentries.addElement(jj_expentry);
3319 if (pos != 0) jj_lasttokens[(jj_endpos = pos) - 1] = kind;
3320 }
3321 }
3322
3323 public ParseException generateParseException() {
3324 jj_expentries.removeAllElements();
3325 boolean[] la1tokens = new boolean[130];
3326 for (int i = 0; i < 130; i++) {
3327 la1tokens[i] = false;
3328 }
3329 if (jj_kind >= 0) {
3330 la1tokens[jj_kind] = true;
3331 jj_kind = -1;
3332 }
3333 for (int i = 0; i < 55; i++) {
3334 if (jj_la1[i] == jj_gen) {
3335 for (int j = 0; j < 32; j++) {
3336 if ((jj_la1_0[i] & (1<<j)) != 0) {
3337 la1tokens[j] = true;
3338 }
3339 if ((jj_la1_1[i] & (1<<j)) != 0) {
3340 la1tokens[32+j] = true;
3341 }
3342 if ((jj_la1_2[i] & (1<<j)) != 0) {
3343 la1tokens[64+j] = true;
3344 }
3345 if ((jj_la1_3[i] & (1<<j)) != 0) {
3346 la1tokens[96+j] = true;
3347 }
3348 if ((jj_la1_4[i] & (1<<j)) != 0) {
3349 la1tokens[128+j] = true;
3350 }
3351 }
3352 }
3353 }
3354 for (int i = 0; i < 130; i++) {
3355 if (la1tokens[i]) {
3356 jj_expentry = new int[1];
3357 jj_expentry[0] = i;
3358 jj_expentries.addElement(jj_expentry);
3359 }
3360 }
3361 jj_endpos = 0;
3362 jj_rescan_token();
3363 jj_add_error_token(0, 0);
3364 int[][] exptokseq = new int[jj_expentries.size()][];
3365 for (int i = 0; i < jj_expentries.size(); i++) {
3366 exptokseq[i] = jj_expentries.elementAt(i);
3367 }
3368 return new ParseException(token, exptokseq, tokenImage);
3369 }
3370
3371 final public void enable_tracing() {
3372 }
3373
3374 final public void disable_tracing() {
3375 }
3376
3377 final private void jj_rescan_token() {
3378 jj_rescan = true;
3379 for (int i = 0; i < 16; i++) {
3380 JJCalls p = jj_2_rtns[i];
3381 do {
3382 if (p.gen > jj_gen) {
3383 jj_la = p.arg; jj_lastpos = jj_scanpos = p.first;
3384 switch (i) {
3385 case 0: jj_3_1(); break;
3386 case 1: jj_3_2(); break;
3387 case 2: jj_3_3(); break;
3388 case 3: jj_3_4(); break;
3389 case 4: jj_3_5(); break;
3390 case 5: jj_3_6(); break;
3391 case 6: jj_3_7(); break;
3392 case 7: jj_3_8(); break;
3393 case 8: jj_3_9(); break;
3394 case 9: jj_3_10(); break;
3395 case 10: jj_3_11(); break;
3396 case 11: jj_3_12(); break;
3397 case 12: jj_3_13(); break;
3398 case 13: jj_3_14(); break;
3399 case 14: jj_3_15(); break;
3400 case 15: jj_3_16(); break;
3401 }
3402 }
3403 p = p.next;
3404 } while (p != null);
3405 }
3406 jj_rescan = false;
3407 }
3408
3409 final private void jj_save(int index, int xla) {
3410 JJCalls p = jj_2_rtns[index];
3411 while (p.gen > jj_gen) {
3412 if (p.next == null) { p = p.next = new JJCalls(); break; }
3413 p = p.next;
3414 }
3415 p.gen = jj_gen + xla - jj_la; p.first = token; p.arg = xla;
3416 }
3417
3418 static final class JJCalls {
3419 int gen;
3420 Token first;
3421 int arg;
3422 JJCalls next;
3423 }
3424
3425}
3426 |
Popular Tags |
Java API By Example, From Geeks To Geeks.