|
1
2 package bsh;
3
4 import java.io.*;
5 import java.util.Vector  ;
6
7
32 public class Parserimplements ParserTreeConstants, ParserConstants {
33 protected JJTParserState jjtree = new JJTParserState();boolean retainComments = false;
34
35 public void setRetainComments( boolean b ) {
36 retainComments = b;
37 }
38
39 void jjtreeOpenNodeScope(Node n) {
40 ((SimpleNode)n).firstToken = getToken(1);
41 }
42
43 void jjtreeCloseNodeScope(Node n) {
44 ((SimpleNode)n).lastToken = getToken(0);
45 }
46
47
50 void reInitInput( Reader in ) {
51 ReInit(in);
52 }
53
54 public SimpleNode popNode()
55 {
56 if ( jjtree.nodeArity() > 0) return (SimpleNode)jjtree.popNode();
58 else
59 return null;
60 }
61
62
67 void reInitTokenInput( Reader in ) {
68 jj_input_stream.ReInit( in,
69 jj_input_stream.getEndLine(),
70 jj_input_stream.getEndColumn() );
71 }
72
73 public static void main( String [] args )
74 throws IOException, ParseException
75 {
76 boolean print = false;
77 int i=0;
78 if ( args[0].equals("-p") ) {
79 i++;
80 print=true;
81 }
82 for(; i< args.length; i++) {
83 Reader in = new FileReader(args[i]);
84 Parser parser = new Parser(in);
85 parser.setRetainComments(true);
86 while( !parser.Line() )
87 if ( print )
88 System.out.println( parser.popNode() );
89 }
90 }
91
92
96 boolean isRegularForStatement()
97 {
98 int curTok = 1;
99 Token tok;
100 tok = getToken(curTok++);
101 if ( tok.kind != FOR ) return false;
102 tok = getToken(curTok++);
103 if ( tok.kind != LPAREN ) return false;
104 while (true)
105 {
106 tok = getToken(curTok++);
107 switch (tok.kind) {
108 case COLON:
109 return false;
110 case SEMICOLON:
111 return true;
112 case EOF:
113 return false;
114 }
115 }
116 }
117
118
124 ParseException createParseException( String message )
125 {
126 Token errortok = token;
127 int line = errortok.beginLine, column = errortok.beginColumn;
128 String mess = (errortok.kind == 0) ? tokenImage[0] : errortok.image;
129 return new ParseException( "Parse error at line " + line
130 + ", column " + column + " : " + message );
131 }
132
133
137 final public boolean Line() throws ParseException {
138 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
139 case 0:
140 jj_consume_token(0);
141 Interpreter.debug("End of File!");
142 {if (true) return true;}
143 break;
144 default:
145 if (jj_2_1(1)) {
146 BlockStatement();
147 {if (true) return false;}
148 } else {
149 jj_consume_token(-1);
150 throw new ParseException();
151 }
152 }
153 throw new Error ("Missing return statement in function");
154 }
155
156
159
160
166 final public Modifiers Modifiers(int context, boolean lookahead) throws ParseException {
167 Modifiers mods = null;
168 label_1:
169 while (true) {
170 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
171 case ABSTRACT:
172 case FINAL:
173 case NATIVE:
174 case PRIVATE:
175 case PROTECTED:
176 case PUBLIC:
177 case STATIC:
178 case STRICTFP:
179 case SYNCHRONIZED:
180 case TRANSIENT:
181 case VOLATILE:
182 ;
183 break;
184 default:
185 break label_1;
186 }
187 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
188 case PRIVATE:
189 jj_consume_token(PRIVATE);
190 break;
191 case PROTECTED:
192 jj_consume_token(PROTECTED);
193 break;
194 case PUBLIC:
195 jj_consume_token(PUBLIC);
196 break;
197 case SYNCHRONIZED:
198 jj_consume_token(SYNCHRONIZED);
199 break;
200 case FINAL:
201 jj_consume_token(FINAL);
202 break;
203 case NATIVE:
204 jj_consume_token(NATIVE);
205 break;
206 case TRANSIENT:
207 jj_consume_token(TRANSIENT);
208 break;
209 case VOLATILE:
210 jj_consume_token(VOLATILE);
211 break;
212 case ABSTRACT:
213 jj_consume_token(ABSTRACT);
214 break;
215 case STATIC:
216 jj_consume_token(STATIC);
217 break;
218 case STRICTFP:
219 jj_consume_token(STRICTFP);
220 break;
221 default:
222 jj_consume_token(-1);
223 throw new ParseException();
224 }
225 if ( !lookahead )
226 try {
227 if ( mods == null ) mods = new Modifiers();
228 mods.addModifier( context, getToken(0).image );
229 } catch ( IllegalStateException e ) {
230 {if (true) throw createParseException( e.getMessage() );}
231 }
232 }
233 {if (true) return mods;}
234 throw new Error ("Missing return statement in function");
235 }
236
237
239 final public void ClassDeclaration() throws ParseException {
240
241 BSHClassDeclaration jjtn000 = new BSHClassDeclaration(JJTCLASSDECLARATION);
242 boolean jjtc000 = true;
243 jjtree.openNodeScope(jjtn000);
244 jjtreeOpenNodeScope(jjtn000);Modifiers mods;
245 Token name;
246 int numInterfaces;
247 try {
248 mods = Modifiers(Modifiers.CLASS, false);
249 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
250 case CLASS:
251 jj_consume_token(CLASS);
252 break;
253 case INTERFACE:
254 jj_consume_token(INTERFACE);
255 jjtn000.isInterface=true;
256 break;
257 default:
258 jj_consume_token(-1);
259 throw new ParseException();
260 }
261 name = jj_consume_token(IDENTIFIER);
262 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
263 case EXTENDS:
264 jj_consume_token(EXTENDS);
265 AmbiguousName();
266 jjtn000.extend = true;
267 break;
268 default:
269 ;
270 }
271 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
272 case IMPLEMENTS:
273 jj_consume_token(IMPLEMENTS);
274 numInterfaces = NameList();
275 jjtn000.numInterfaces=numInterfaces;
276 break;
277 default:
278 ;
279 }
280 Block();
281 jjtree.closeNodeScope(jjtn000, true);
282 jjtc000 = false;
283 jjtreeCloseNodeScope(jjtn000);
284 jjtn000.modifiers = mods;
285 jjtn000.name = name.image;
286 } catch (Throwable jjte000) {
287 if (jjtc000) {
288 jjtree.clearNodeScope(jjtn000);
289 jjtc000 = false;
290 } else {
291 jjtree.popNode();
292 }
293 if (jjte000 instanceof RuntimeException ) {
294 {if (true) throw (RuntimeException )jjte000;}
295 }
296 if (jjte000 instanceof ParseException) {
297 {if (true) throw (ParseException)jjte000;}
298 }
299 {if (true) throw (Error )jjte000;}
300 } finally {
301 if (jjtc000) {
302 jjtree.closeNodeScope(jjtn000, true);
303 jjtreeCloseNodeScope(jjtn000);
304 }
305 }
306 }
307
308 final public void MethodDeclaration() throws ParseException {
309
310 BSHMethodDeclaration jjtn000 = new BSHMethodDeclaration(JJTMETHODDECLARATION);
311 boolean jjtc000 = true;
312 jjtree.openNodeScope(jjtn000);
313 jjtreeOpenNodeScope(jjtn000);Token t = null;
314 Modifiers mods;
315 int count;
316 try {
317 mods = Modifiers(Modifiers.METHOD, false);
318 jjtn000.modifiers = mods;
319 if (jj_2_2(2147483647)) {
320 t = jj_consume_token(IDENTIFIER);
321 jjtn000.name = t.image;
322 } else {
323 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
324 case BOOLEAN:
325 case BYTE:
326 case CHAR:
327 case DOUBLE:
328 case FLOAT:
329 case INT:
330 case LONG:
331 case SHORT:
332 case VOID:
333 case IDENTIFIER:
334 ReturnType();
335 t = jj_consume_token(IDENTIFIER);
336 jjtn000.name = t.image;
337 break;
338 default:
339 jj_consume_token(-1);
340 throw new ParseException();
341 }
342 }
343 FormalParameters();
344 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
345 case THROWS:
346 jj_consume_token(THROWS);
347 count = NameList();
348 jjtn000.numThrows=count;
349 break;
350 default:
351 ;
352 }
353 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
354 case LBRACE:
355 Block();
356 break;
357 case SEMICOLON:
358 jj_consume_token(SEMICOLON);
359 break;
360 default:
361 jj_consume_token(-1);
362 throw new ParseException();
363 }
364 } catch (Throwable jjte000) {
365 if (jjtc000) {
366 jjtree.clearNodeScope(jjtn000);
367 jjtc000 = false;
368 } else {
369 jjtree.popNode();
370 }
371 if (jjte000 instanceof RuntimeException ) {
372 {if (true) throw (RuntimeException )jjte000;}
373 }
374 if (jjte000 instanceof ParseException) {
375 {if (true) throw (ParseException)jjte000;}
376 }
377 {if (true) throw (Error )jjte000;}
378 } finally {
379 if (jjtc000) {
380 jjtree.closeNodeScope(jjtn000, true);
381 jjtreeCloseNodeScope(jjtn000);
382 }
383 }
384 }
385
386 final public void PackageDeclaration() throws ParseException {
387
388 BSHPackageDeclaration jjtn000 = new BSHPackageDeclaration(JJTPACKAGEDECLARATION);
389 boolean jjtc000 = true;
390 jjtree.openNodeScope(jjtn000);
391 jjtreeOpenNodeScope(jjtn000);
392 try {
393 jj_consume_token(PACKAGE);
394 AmbiguousName();
395 } catch (Throwable jjte000) {
396 if (jjtc000) {
397 jjtree.clearNodeScope(jjtn000);
398 jjtc000 = false;
399 } else {
400 jjtree.popNode();
401 }
402 if (jjte000 instanceof RuntimeException ) {
403 {if (true) throw (RuntimeException )jjte000;}
404 }
405 if (jjte000 instanceof ParseException) {
406 {if (true) throw (ParseException)jjte000;}
407 }
408 {if (true) throw (Error )jjte000;}
409 } finally {
410 if (jjtc000) {
411 jjtree.closeNodeScope(jjtn000, true);
412 jjtreeCloseNodeScope(jjtn000);
413 }
414 }
415 }
416
417 final public void ImportDeclaration() throws ParseException {
418
419 BSHImportDeclaration jjtn000 = new BSHImportDeclaration(JJTIMPORTDECLARATION);
420 boolean jjtc000 = true;
421 jjtree.openNodeScope(jjtn000);
422 jjtreeOpenNodeScope(jjtn000);Token s = null;
423 Token t = null;
424 try {
425 if (jj_2_3(3)) {
426 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
427 case STATIC:
428 s = jj_consume_token(STATIC);
429 break;
430 default:
431 ;
432 }
433 jj_consume_token(IMPORT);
434 AmbiguousName();
435 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
436 case DOT:
437 t = jj_consume_token(DOT);
438 jj_consume_token(STAR);
439 break;
440 default:
441 ;
442 }
443 jj_consume_token(SEMICOLON);
444 jjtree.closeNodeScope(jjtn000, true);
445 jjtc000 = false;
446 jjtreeCloseNodeScope(jjtn000);
447 if ( s != null ) jjtn000.staticImport = true;
448 if ( t != null ) jjtn000.importPackage = true;
449 } else {
450 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
451 case IMPORT:
452 jj_consume_token(IMPORT);
453 jj_consume_token(STAR);
454 jj_consume_token(SEMICOLON);
455 jjtree.closeNodeScope(jjtn000, true);
456 jjtc000 = false;
457 jjtreeCloseNodeScope(jjtn000);
458 jjtn000.superImport = true;
459 break;
460 default:
461 jj_consume_token(-1);
462 throw new ParseException();
463 }
464 }
465 } catch (Throwable jjte000) {
466 if (jjtc000) {
467 jjtree.clearNodeScope(jjtn000);
468 jjtc000 = false;
469 } else {
470 jjtree.popNode();
471 }
472 if (jjte000 instanceof RuntimeException ) {
473 {if (true) throw (RuntimeException )jjte000;}
474 }
475 if (jjte000 instanceof ParseException) {
476 {if (true) throw (ParseException)jjte000;}
477 }
478 {if (true) throw (Error )jjte000;}
479 } finally {
480 if (jjtc000) {
481 jjtree.closeNodeScope(jjtn000, true);
482 jjtreeCloseNodeScope(jjtn000);
483 }
484 }
485 }
486
487 final public void VariableDeclarator() throws ParseException {
488
489 BSHVariableDeclarator jjtn000 = new BSHVariableDeclarator(JJTVARIABLEDECLARATOR);
490 boolean jjtc000 = true;
491 jjtree.openNodeScope(jjtn000);
492 jjtreeOpenNodeScope(jjtn000);Token t;
493 try {
494 t = jj_consume_token(IDENTIFIER);
495 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
496 case ASSIGN:
497 jj_consume_token(ASSIGN);
498 VariableInitializer();
499 break;
500 default:
501 ;
502 }
503 jjtree.closeNodeScope(jjtn000, true);
504 jjtc000 = false;
505 jjtreeCloseNodeScope(jjtn000);
506 jjtn000.name = t.image;
507 } catch (Throwable jjte000) {
508 if (jjtc000) {
509 jjtree.clearNodeScope(jjtn000);
510 jjtc000 = false;
511 } else {
512 jjtree.popNode();
513 }
514 if (jjte000 instanceof RuntimeException ) {
515 {if (true) throw (RuntimeException )jjte000;}
516 }
517 if (jjte000 instanceof ParseException) {
518 {if (true) throw (ParseException)jjte000;}
519 }
520 {if (true) throw (Error )jjte000;}
521 } finally {
522 if (jjtc000) {
523 jjtree.closeNodeScope(jjtn000, true);
524 jjtreeCloseNodeScope(jjtn000);
525 }
526 }
527 }
528
529
539 final public void VariableInitializer() throws ParseException {
540 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
541 case LBRACE:
542 ArrayInitializer();
543 break;
544 case BOOLEAN:
545 case BYTE:
546 case CHAR:
547 case DOUBLE:
548 case FALSE:
549 case FLOAT:
550 case INT:
551 case LONG:
552 case NEW:
553 case NULL:
554 case SHORT:
555 case TRUE:
556 case VOID:
557 case INTEGER_LITERAL:
558 case FLOATING_POINT_LITERAL:
559 case CHARACTER_LITERAL:
560 case STRING_LITERAL:
561 case IDENTIFIER:
562 case LPAREN:
563 case BANG:
564 case TILDE:
565 case INCR:
566 case DECR:
567 case PLUS:
568 case MINUS:
569 Expression();
570 break;
571 default:
572 jj_consume_token(-1);
573 throw new ParseException();
574 }
575 }
576
577 final public void ArrayInitializer() throws ParseException {
578
579 BSHArrayInitializer jjtn000 = new BSHArrayInitializer(JJTARRAYINITIALIZER);
580 boolean jjtc000 = true;
581 jjtree.openNodeScope(jjtn000);
582 jjtreeOpenNodeScope(jjtn000);
583 try {
584 jj_consume_token(LBRACE);
585 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
586 case BOOLEAN:
587 case BYTE:
588 case CHAR:
589 case DOUBLE:
590 case FALSE:
591 case FLOAT:
592 case INT:
593 case LONG:
594 case NEW:
595 case NULL:
596 case SHORT:
597 case TRUE:
598 case VOID:
599 case INTEGER_LITERAL:
600 case FLOATING_POINT_LITERAL:
601 case CHARACTER_LITERAL:
602 case STRING_LITERAL:
603 case IDENTIFIER:
604 case LPAREN:
605 case LBRACE:
606 case BANG:
607 case TILDE:
608 case INCR:
609 case DECR:
610 case PLUS:
611 case MINUS:
612 VariableInitializer();
613 label_2:
614 while (true) {
615 if (jj_2_4(2)) {
616 ;
617 } else {
618 break label_2;
619 }
620 jj_consume_token(COMMA);
621 VariableInitializer();
622 }
623 break;
624 default:
625 ;
626 }
627 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
628 case COMMA:
629 jj_consume_token(COMMA);
630 break;
631 default:
632 ;
633 }
634 jj_consume_token(RBRACE);
635 } catch (Throwable jjte000) {
636 if (jjtc000) {
637 jjtree.clearNodeScope(jjtn000);
638 jjtc000 = false;
639 } else {
640 jjtree.popNode();
641 }
642 if (jjte000 instanceof RuntimeException ) {
643 {if (true) throw (RuntimeException )jjte000;}
644 }
645 if (jjte000 instanceof ParseException) {
646 {if (true) throw (ParseException)jjte000;}
647 }
648 {if (true) throw (Error )jjte000;}
649 } finally {
650 if (jjtc000) {
651 jjtree.closeNodeScope(jjtn000, true);
652 jjtreeCloseNodeScope(jjtn000);
653 }
654 }
655 }
656
657 final public void FormalParameters() throws ParseException {
658
659 BSHFormalParameters jjtn000 = new BSHFormalParameters(JJTFORMALPARAMETERS);
660 boolean jjtc000 = true;
661 jjtree.openNodeScope(jjtn000);
662 jjtreeOpenNodeScope(jjtn000);
663 try {
664 jj_consume_token(LPAREN);
665 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
666 case BOOLEAN:
667 case BYTE:
668 case CHAR:
669 case DOUBLE:
670 case FLOAT:
671 case INT:
672 case LONG:
673 case SHORT:
674 case IDENTIFIER:
675 FormalParameter();
676 label_3:
677 while (true) {
678 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
679 case COMMA:
680 ;
681 break;
682 default:
683 break label_3;
684 }
685 jj_consume_token(COMMA);
686 FormalParameter();
687 }
688 break;
689 default:
690 ;
691 }
692 jj_consume_token(RPAREN);
693 } catch (Throwable jjte000) {
694 if (jjtc000) {
695 jjtree.clearNodeScope(jjtn000);
696 jjtc000 = false;
697 } else {
698 jjtree.popNode();
699 }
700 if (jjte000 instanceof RuntimeException ) {
701 {if (true) throw (RuntimeException )jjte000;}
702 }
703 if (jjte000 instanceof ParseException) {
704 {if (true) throw (ParseException)jjte000;}
705 }
706 {if (true) throw (Error )jjte000;}
707 } finally {
708 if (jjtc000) {
709 jjtree.closeNodeScope(jjtn000, true);
710 jjtreeCloseNodeScope(jjtn000);
711 }
712 }
713 }
714
715 final public void FormalParameter() throws ParseException {
716
717 BSHFormalParameter jjtn000 = new BSHFormalParameter(JJTFORMALPARAMETER);
718 boolean jjtc000 = true;
719 jjtree.openNodeScope(jjtn000);
720 jjtreeOpenNodeScope(jjtn000);Token t;
721 try {
722 if (jj_2_5(2)) {
723 Type();
724 t = jj_consume_token(IDENTIFIER);
725 jjtree.closeNodeScope(jjtn000, true);
726 jjtc000 = false;
727 jjtreeCloseNodeScope(jjtn000);
728 jjtn000.name = t.image;
729 } else {
730 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
731 case IDENTIFIER:
732 t = jj_consume_token(IDENTIFIER);
733 jjtree.closeNodeScope(jjtn000, true);
734 jjtc000 = false;
735 jjtreeCloseNodeScope(jjtn000);
736 jjtn000.name = t.image;
737 break;
738 default:
739 jj_consume_token(-1);
740 throw new ParseException();
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 jjtreeCloseNodeScope(jjtn000);
761 }
762 }
763 }
764
765
768 final public void Type() throws ParseException {
769
770 BSHType jjtn000 = new BSHType(JJTTYPE);
771 boolean jjtc000 = true;
772 jjtree.openNodeScope(jjtn000);
773 jjtreeOpenNodeScope(jjtn000);
774 try {
775 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
776 case BOOLEAN:
777 case BYTE:
778 case CHAR:
779 case DOUBLE:
780 case FLOAT:
781 case INT:
782 case LONG:
783 case SHORT:
784 PrimitiveType();
785 break;
786 case IDENTIFIER:
787 AmbiguousName();
788 break;
789 default:
790 jj_consume_token(-1);
791 throw new ParseException();
792 }
793 label_4:
794 while (true) {
795 if (jj_2_6(2)) {
796 ;
797 } else {
798 break label_4;
799 }
800 jj_consume_token(LBRACKET);
801 jj_consume_token(RBRACKET);
802 jjtn000.addArrayDimension();
803 }
804 } catch (Throwable jjte000) {
805 if (jjtc000) {
806 jjtree.clearNodeScope(jjtn000);
807 jjtc000 = false;
808 } else {
809 jjtree.popNode();
810 }
811 if (jjte000 instanceof RuntimeException ) {
812 {if (true) throw (RuntimeException )jjte000;}
813 }
814 if (jjte000 instanceof ParseException) {
815 {if (true) throw (ParseException)jjte000;}
816 }
817 {if (true) throw (Error )jjte000;}
818 } finally {
819 if (jjtc000) {
820 jjtree.closeNodeScope(jjtn000, true);
821 jjtreeCloseNodeScope(jjtn000);
822 }
823 }
824 }
825
826
829 final public void ReturnType() throws ParseException {
830
831 BSHReturnType jjtn000 = new BSHReturnType(JJTRETURNTYPE);
832 boolean jjtc000 = true;
833 jjtree.openNodeScope(jjtn000);
834 jjtreeOpenNodeScope(jjtn000);
835 try {
836 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
837 case VOID:
838 jj_consume_token(VOID);
839 jjtree.closeNodeScope(jjtn000, true);
840 jjtc000 = false;
841 jjtreeCloseNodeScope(jjtn000);
842 jjtn000.isVoid = true;
843 break;
844 case BOOLEAN:
845 case BYTE:
846 case CHAR:
847 case DOUBLE:
848 case FLOAT:
849 case INT:
850 case LONG:
851 case SHORT:
852 case IDENTIFIER:
853 Type();
854 break;
855 default:
856 jj_consume_token(-1);
857 throw new ParseException();
858 }
859 } catch (Throwable jjte000) {
860 if (jjtc000) {
861 jjtree.clearNodeScope(jjtn000);
862 jjtc000 = false;
863 } else {
864 jjtree.popNode();
865 }
866 if (jjte000 instanceof RuntimeException ) {
867 {if (true) throw (RuntimeException )jjte000;}
868 }
869 if (jjte000 instanceof ParseException) {
870 {if (true) throw (ParseException)jjte000;}
871 }
872 {if (true) throw (Error )jjte000;}
873 } finally {
874 if (jjtc000) {
875 jjtree.closeNodeScope(jjtn000, true);
876 jjtreeCloseNodeScope(jjtn000);
877 }
878 }
879 }
880
881 final public void PrimitiveType() throws ParseException {
882
883 BSHPrimitiveType jjtn000 = new BSHPrimitiveType(JJTPRIMITIVETYPE);
884 boolean jjtc000 = true;
885 jjtree.openNodeScope(jjtn000);
886 jjtreeOpenNodeScope(jjtn000);
887 try {
888 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
889 case BOOLEAN:
890 jj_consume_token(BOOLEAN);
891 jjtree.closeNodeScope(jjtn000, true);
892 jjtc000 = false;
893 jjtreeCloseNodeScope(jjtn000);
894 jjtn000.type = Boolean.TYPE;
895 break;
896 case CHAR:
897 jj_consume_token(CHAR);
898 jjtree.closeNodeScope(jjtn000, true);
899 jjtc000 = false;
900 jjtreeCloseNodeScope(jjtn000);
901 jjtn000.type = Character.TYPE;
902 break;
903 case BYTE:
904 jj_consume_token(BYTE);
905 jjtree.closeNodeScope(jjtn000, true);
906 jjtc000 = false;
907 jjtreeCloseNodeScope(jjtn000);
908 jjtn000.type = Byte.TYPE;
909 break;
910 case SHORT:
911 jj_consume_token(SHORT);
912 jjtree.closeNodeScope(jjtn000, true);
913 jjtc000 = false;
914 jjtreeCloseNodeScope(jjtn000);
915 jjtn000.type = Short.TYPE;
916 break;
917 case INT:
918 jj_consume_token(INT);
919 jjtree.closeNodeScope(jjtn000, true);
920 jjtc000 = false;
921 jjtreeCloseNodeScope(jjtn000);
922 jjtn000.type = Integer.TYPE;
923 break;
924 case LONG:
925 jj_consume_token(LONG);
926 jjtree.closeNodeScope(jjtn000, true);
927 jjtc000 = false;
928 jjtreeCloseNodeScope(jjtn000);
929 jjtn000.type = Long.TYPE;
930 break;
931 case FLOAT:
932 jj_consume_token(FLOAT);
933 jjtree.closeNodeScope(jjtn000, true);
934 jjtc000 = false;
935 jjtreeCloseNodeScope(jjtn000);
936 jjtn000.type = Float.TYPE;
937 break;
938 case DOUBLE:
939 jj_consume_token(DOUBLE);
940 jjtree.closeNodeScope(jjtn000, true);
941 jjtc000 = false;
942 jjtreeCloseNodeScope(jjtn000);
943 jjtn000.type = Double.TYPE;
944 break;
945 default:
946 jj_consume_token(-1);
947 throw new ParseException();
948 }
949 } finally {
950 if (jjtc000) {
951 jjtree.closeNodeScope(jjtn000, true);
952 jjtreeCloseNodeScope(jjtn000);
953 }
954 }
955 }
956
957 final public void AmbiguousName() throws ParseException {
958
959 BSHAmbiguousName jjtn000 = new BSHAmbiguousName(JJTAMBIGUOUSNAME);
960 boolean jjtc000 = true;
961 jjtree.openNodeScope(jjtn000);
962 jjtreeOpenNodeScope(jjtn000);Token t;
963 StringBuffer s;
964 try {
965 t = jj_consume_token(IDENTIFIER);
966 s = new StringBuffer (t.image);
967 label_5:
968 while (true) {
969 if (jj_2_7(2)) {
970 ;
971 } else {
972 break label_5;
973 }
974 jj_consume_token(DOT);
975 t = jj_consume_token(IDENTIFIER);
976 s.append("."+t.image);
977 }
978 jjtree.closeNodeScope(jjtn000, true);
979 jjtc000 = false;
980 jjtreeCloseNodeScope(jjtn000);
981 jjtn000.text = s.toString();
982 } finally {
983 if (jjtc000) {
984 jjtree.closeNodeScope(jjtn000, true);
985 jjtreeCloseNodeScope(jjtn000);
986 }
987 }
988 }
989
990 final public int NameList() throws ParseException {
991 int count = 0;
992 AmbiguousName();
993 ++count;
994 label_6:
995 while (true) {
996 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
997 case COMMA:
998 ;
999 break;
1000 default:
1001 break label_6;
1002 }
1003 jj_consume_token(COMMA);
1004 AmbiguousName();
1005 ++count;
1006 }
1007 {if (true) return count;}
1008 throw new Error ("Missing return statement in function");
1009 }
1010
1011
1014 final public void Expression() throws ParseException {
1015 if (jj_2_8(2147483647)) {
1016 Assignment();
1017 } else {
1018 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1019 case BOOLEAN:
1020 case BYTE:
1021 case CHAR:
1022 case DOUBLE:
1023 case FALSE:
1024 case FLOAT:
1025 case INT:
1026 case LONG:
1027 case NEW:
1028 case NULL:
1029 case SHORT:
1030 case TRUE:
1031 case VOID:
1032 case INTEGER_LITERAL:
1033 case FLOATING_POINT_LITERAL:
1034 case CHARACTER_LITERAL:
1035 case STRING_LITERAL:
1036 case IDENTIFIER:
1037 case LPAREN:
1038 case BANG:
1039 case TILDE:
1040 case INCR:
1041 case DECR:
1042 case PLUS:
1043 case MINUS:
1044 ConditionalExpression();
1045 break;
1046 default:
1047 jj_consume_token(-1);
1048 throw new ParseException();
1049 }
1050 }
1051 }
1052
1053 final public void Assignment() throws ParseException {
1054
1055 BSHAssignment jjtn000 = new BSHAssignment(JJTASSIGNMENT);
1056 boolean jjtc000 = true;
1057 jjtree.openNodeScope(jjtn000);
1058 jjtreeOpenNodeScope(jjtn000);int op ;
1059 try {
1060 PrimaryExpression();
1061 op = AssignmentOperator();
1062 jjtn000.operator = op;
1063 Expression();
1064 } catch (Throwable jjte000) {
1065 if (jjtc000) {
1066 jjtree.clearNodeScope(jjtn000);
1067 jjtc000 = false;
1068 } else {
1069 jjtree.popNode();
1070 }
1071 if (jjte000 instanceof RuntimeException ) {
1072 {if (true) throw (RuntimeException )jjte000;}
1073 }
1074 if (jjte000 instanceof ParseException) {
1075 {if (true) throw (ParseException)jjte000;}
1076 }
1077 {if (true) throw (Error )jjte000;}
1078 } finally {
1079 if (jjtc000) {
1080 jjtree.closeNodeScope(jjtn000, true);
1081 jjtreeCloseNodeScope(jjtn000);
1082 }
1083 }
1084 }
1085
1086 final public int AssignmentOperator() throws ParseException {
1087 Token t;
1088 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1089 case ASSIGN:
1090 jj_consume_token(ASSIGN);
1091 break;
1092 case STARASSIGN:
1093 jj_consume_token(STARASSIGN);
1094 break;
1095 case SLASHASSIGN:
1096 jj_consume_token(SLASHASSIGN);
1097 break;
1098 case MODASSIGN:
1099 jj_consume_token(MODASSIGN);
1100 break;
1101 case PLUSASSIGN:
1102 jj_consume_token(PLUSASSIGN);
1103 break;
1104 case MINUSASSIGN:
1105 jj_consume_token(MINUSASSIGN);
1106 break;
1107 case ANDASSIGN:
1108 jj_consume_token(ANDASSIGN);
1109 break;
1110 case XORASSIGN:
1111 jj_consume_token(XORASSIGN);
1112 break;
1113 case ORASSIGN:
1114 jj_consume_token(ORASSIGN);
1115 break;
1116 case LSHIFTASSIGN:
1117 jj_consume_token(LSHIFTASSIGN);
1118 break;
1119 case LSHIFTASSIGNX:
1120 jj_consume_token(LSHIFTASSIGNX);
1121 break;
1122 case RSIGNEDSHIFTASSIGN:
1123 jj_consume_token(RSIGNEDSHIFTASSIGN);
1124 break;
1125 case RSIGNEDSHIFTASSIGNX:
1126 jj_consume_token(RSIGNEDSHIFTASSIGNX);
1127 break;
1128 case RUNSIGNEDSHIFTASSIGN:
1129 jj_consume_token(RUNSIGNEDSHIFTASSIGN);
1130 break;
1131 case RUNSIGNEDSHIFTASSIGNX:
1132 jj_consume_token(RUNSIGNEDSHIFTASSIGNX);
1133 break;
1134 default:
1135 jj_consume_token(-1);
1136 throw new ParseException();
1137 }
1138 t = getToken(0);
1139 {if (true) return t.kind;}
1140 throw new Error ("Missing return statement in function");
1141 }
1142
1143 final public void ConditionalExpression() throws ParseException {
1144 ConditionalOrExpression();
1145 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1146 case HOOK:
1147 jj_consume_token(HOOK);
1148 Expression();
1149 jj_consume_token(COLON);
1150 BSHTernaryExpression jjtn001 = new BSHTernaryExpression(JJTTERNARYEXPRESSION);
1151 boolean jjtc001 = true;
1152 jjtree.openNodeScope(jjtn001);
1153 jjtreeOpenNodeScope(jjtn001);
1154 try {
1155 ConditionalExpression();
1156 } catch (Throwable jjte001) {
1157 if (jjtc001) {
1158 jjtree.clearNodeScope(jjtn001);
1159 jjtc001 = false;
1160 } else {
1161 jjtree.popNode();
1162 }
1163 if (jjte001 instanceof RuntimeException ) {
1164 {if (true) throw (RuntimeException )jjte001;}
1165 }
1166 if (jjte001 instanceof ParseException) {
1167 {if (true) throw (ParseException)jjte001;}
1168 }
1169 {if (true) throw (Error )jjte001;}
1170 } finally {
1171 if (jjtc001) {
1172 jjtree.closeNodeScope(jjtn001, 3);
1173 jjtreeCloseNodeScope(jjtn001);
1174 }
1175 }
1176 break;
1177 default:
1178 ;
1179 }
1180 }
1181
1182 final public void ConditionalOrExpression() throws ParseException {
1183 Token t=null;
1184 ConditionalAndExpression();
1185 label_7:
1186 while (true) {
1187 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1188 case BOOL_OR:
1189 case BOOL_ORX:
1190 ;
1191 break;
1192 default:
1193 break label_7;
1194 }
1195 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1196 case BOOL_OR:
1197 t = jj_consume_token(BOOL_OR);
1198 break;
1199 case BOOL_ORX:
1200 t = jj_consume_token(BOOL_ORX);
1201 break;
1202 default:
1203 jj_consume_token(-1);
1204 throw new ParseException();
1205 }
1206 ConditionalAndExpression();
1207 BSHBinaryExpression jjtn001 = new BSHBinaryExpression(JJTBINARYEXPRESSION);
1208 boolean jjtc001 = true;
1209 jjtree.openNodeScope(jjtn001);
1210 jjtreeOpenNodeScope(jjtn001);
1211 try {
1212 jjtree.closeNodeScope(jjtn001, 2);
1213 jjtc001 = false;
1214 jjtreeCloseNodeScope(jjtn001);
1215 jjtn001.kind = t.kind;
1216 } finally {
1217 if (jjtc001) {
1218 jjtree.closeNodeScope(jjtn001, 2);
1219 jjtreeCloseNodeScope(jjtn001);
1220 }
1221 }
1222 }
1223 }
1224
1225 final public void ConditionalAndExpression() throws ParseException {
1226 Token t=null;
1227 InclusiveOrExpression();
1228 label_8:
1229 while (true) {
1230 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1231 case BOOL_AND:
1232 case BOOL_ANDX:
1233 ;
1234 break;
1235 default:
1236 break label_8;
1237 }
1238 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1239 case BOOL_AND:
1240 t = jj_consume_token(BOOL_AND);
1241 break;
1242 case BOOL_ANDX:
1243 t = jj_consume_token(BOOL_ANDX);
1244 break;
1245 default:
1246 jj_consume_token(-1);
1247 throw new ParseException();
1248 }
1249 InclusiveOrExpression();
1250 BSHBinaryExpression jjtn001 = new BSHBinaryExpression(JJTBINARYEXPRESSION);
1251 boolean jjtc001 = true;
1252 jjtree.openNodeScope(jjtn001);
1253 jjtreeOpenNodeScope(jjtn001);
1254 try {
1255 jjtree.closeNodeScope(jjtn001, 2);
1256 jjtc001 = false;
1257 jjtreeCloseNodeScope(jjtn001);
1258 jjtn001.kind = t.kind;
1259 } finally {
1260 if (jjtc001) {
1261 jjtree.closeNodeScope(jjtn001, 2);
1262 jjtreeCloseNodeScope(jjtn001);
1263 }
1264 }
1265 }
1266 }
1267
1268 final public void InclusiveOrExpression() throws ParseException {
1269 Token t=null;
1270 ExclusiveOrExpression();
1271 label_9:
1272 while (true) {
1273 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1274 case BIT_OR:
1275 case BIT_ORX:
1276 ;
1277 break;
1278 default:
1279 break label_9;
1280 }
1281 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1282 case BIT_OR:
1283 t = jj_consume_token(BIT_OR);
1284 break;
1285 case BIT_ORX:
1286 t = jj_consume_token(BIT_ORX);
1287 break;
1288 default:
1289 jj_consume_token(-1);
1290 throw new ParseException();
1291 }
1292 ExclusiveOrExpression();
1293 BSHBinaryExpression jjtn001 = new BSHBinaryExpression(JJTBINARYEXPRESSION);
1294 boolean jjtc001 = true;
1295 jjtree.openNodeScope(jjtn001);
1296 jjtreeOpenNodeScope(jjtn001);
1297 try {
1298 jjtree.closeNodeScope(jjtn001, 2);
1299 jjtc001 = false;
1300 jjtreeCloseNodeScope(jjtn001);
1301 jjtn001.kind = t.kind;
1302 } finally {
1303 if (jjtc001) {
1304 jjtree.closeNodeScope(jjtn001, 2);
1305 jjtreeCloseNodeScope(jjtn001);
1306 }
1307 }
1308 }
1309 }
1310
1311 final public void ExclusiveOrExpression() throws ParseException {
1312 Token t=null;
1313 AndExpression();
1314 label_10:
1315 while (true) {
1316 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1317 case XOR:
1318 ;
1319 break;
1320 default:
1321 break label_10;
1322 }
1323 t = jj_consume_token(XOR);
1324 AndExpression();
1325 BSHBinaryExpression jjtn001 = new BSHBinaryExpression(JJTBINARYEXPRESSION);
1326 boolean jjtc001 = true;
1327 jjtree.openNodeScope(jjtn001);
1328 jjtreeOpenNodeScope(jjtn001);
1329 try {
1330 jjtree.closeNodeScope(jjtn001, 2);
1331 jjtc001 = false;
1332 jjtreeCloseNodeScope(jjtn001);
1333 jjtn001.kind = t.kind;
1334 } finally {
1335 if (jjtc001) {
1336 jjtree.closeNodeScope(jjtn001, 2);
1337 jjtreeCloseNodeScope(jjtn001);
1338 }
1339 }
1340 }
1341 }
1342
1343 final public void AndExpression() throws ParseException {
1344 Token t=null;
1345 EqualityExpression();
1346 label_11:
1347 while (true) {
1348 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1349 case BIT_AND:
1350 case BIT_ANDX:
1351 ;
1352 break;
1353 default:
1354 break label_11;
1355 }
1356 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1357 case BIT_AND:
1358 t = jj_consume_token(BIT_AND);
1359 break;
1360 case BIT_ANDX:
1361 t = jj_consume_token(BIT_ANDX);
1362 break;
1363 default:
1364 jj_consume_token(-1);
1365 throw new ParseException();
1366 }
1367 EqualityExpression();
1368 BSHBinaryExpression jjtn001 = new BSHBinaryExpression(JJTBINARYEXPRESSION);
1369 boolean jjtc001 = true;
1370 jjtree.openNodeScope(jjtn001);
1371 jjtreeOpenNodeScope(jjtn001);
1372 try {
1373 jjtree.closeNodeScope(jjtn001, 2);
1374 jjtc001 = false;
1375 jjtreeCloseNodeScope(jjtn001);
1376 jjtn001.kind = t.kind;
1377 } finally {
1378 if (jjtc001) {
1379 jjtree.closeNodeScope(jjtn001, 2);
1380 jjtreeCloseNodeScope(jjtn001);
1381 }
1382 }
1383 }
1384 }
1385
1386 final public void EqualityExpression() throws ParseException {
1387 Token t = null;
1388 InstanceOfExpression();
1389 label_12:
1390 while (true) {
1391 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1392 case EQ:
1393 case NE:
1394 ;
1395 break;
1396 default:
1397 break label_12;
1398 }
1399 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1400 case EQ:
1401 t = jj_consume_token(EQ);
1402 break;
1403 case NE:
1404 t = jj_consume_token(NE);
1405 break;
1406 default:
1407 jj_consume_token(-1);
1408 throw new ParseException();
1409 }
1410 InstanceOfExpression();
1411 BSHBinaryExpression jjtn001 = new BSHBinaryExpression(JJTBINARYEXPRESSION);
1412 boolean jjtc001 = true;
1413 jjtree.openNodeScope(jjtn001);
1414 jjtreeOpenNodeScope(jjtn001);
1415 try {
1416 jjtree.closeNodeScope(jjtn001, 2);
1417 jjtc001 = false;
1418 jjtreeCloseNodeScope(jjtn001);
1419 jjtn001.kind = t.kind;
1420 } finally {
1421 if (jjtc001) {
1422 jjtree.closeNodeScope(jjtn001, 2);
1423 jjtreeCloseNodeScope(jjtn001);
1424 }
1425 }
1426 }
1427 }
1428
1429 final public void InstanceOfExpression() throws ParseException {
1430 Token t = null;
1431 RelationalExpression();
1432 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1433 case INSTANCEOF:
1434 t = jj_consume_token(INSTANCEOF);
1435 Type();
1436 BSHBinaryExpression jjtn001 = new BSHBinaryExpression(JJTBINARYEXPRESSION);
1437 boolean jjtc001 = true;
1438 jjtree.openNodeScope(jjtn001);
1439 jjtreeOpenNodeScope(jjtn001);
1440 try {
1441 jjtree.closeNodeScope(jjtn001, 2);
1442 jjtc001 = false;
1443 jjtreeCloseNodeScope(jjtn001);
1444 jjtn001.kind = t.kind;
1445 } finally {
1446 if (jjtc001) {
1447 jjtree.closeNodeScope(jjtn001, 2);
1448 jjtreeCloseNodeScope(jjtn001);
1449 }
1450 }
1451 break;
1452 default:
1453 ;
1454 }
1455 }
1456
1457 final public void RelationalExpression() throws ParseException {
1458 Token t = null;
1459 ShiftExpression();
1460 label_13:
1461 while (true) {
1462 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1463 case GT:
1464 case GTX:
1465 case LT:
1466 case LTX:
1467 case LE:
1468 case LEX:
1469 case GE:
1470 case GEX:
1471 ;
1472 break;
1473 default:
1474 break label_13;
1475 }
1476 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1477 case LT:
1478 t = jj_consume_token(LT);
1479 break;
1480 case LTX:
1481 t = jj_consume_token(LTX);
1482 break;
1483 case GT:
1484 t = jj_consume_token(GT);
1485 break;
1486 case GTX:
1487 t = jj_consume_token(GTX);
1488 break;
1489 case LE:
1490 t = jj_consume_token(LE);
1491 break;
1492 case LEX:
1493 t = jj_consume_token(LEX);
1494 break;
1495 case GE:
1496 t = jj_consume_token(GE);
1497 break;
1498 case GEX:
1499 t = jj_consume_token(GEX);
1500 break;
1501 default:
1502 jj_consume_token(-1);
1503 throw new ParseException();
1504 }
1505 ShiftExpression();
1506 BSHBinaryExpression jjtn001 = new BSHBinaryExpression(JJTBINARYEXPRESSION);
1507 boolean jjtc001 = true;
1508 jjtree.openNodeScope(jjtn001);
1509 jjtreeOpenNodeScope(jjtn001);
1510 try {
1511 jjtree.closeNodeScope(jjtn001, 2);
1512 jjtc001 = false;
1513 jjtreeCloseNodeScope(jjtn001);
1514 jjtn001.kind = t.kind;
1515 } finally {
1516 if (jjtc001) {
1517 jjtree.closeNodeScope(jjtn001, 2);
1518 jjtreeCloseNodeScope(jjtn001);
1519 }
1520 }
1521 }
1522 }
1523
1524 final public void ShiftExpression() throws ParseException {
1525 Token t = null;
1526 AdditiveExpression();
1527 label_14:
1528 while (true) {
1529 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1530 case LSHIFT:
1531 case LSHIFTX:
1532 case RSIGNEDSHIFT:
1533 case RSIGNEDSHIFTX:
1534 case RUNSIGNEDSHIFT:
1535 case RUNSIGNEDSHIFTX:
1536 ;
1537 break;
1538 default:
1539 break label_14;
1540 }
1541 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1542 case LSHIFT:
1543 t = jj_consume_token(LSHIFT);
1544 break;
1545 case LSHIFTX:
1546 t = jj_consume_token(LSHIFTX);
1547 break;
1548 case RSIGNEDSHIFT:
1549 t = jj_consume_token(RSIGNEDSHIFT);
1550 break;
1551 case RSIGNEDSHIFTX:
1552 t = jj_consume_token(RSIGNEDSHIFTX);
1553 break;
1554 case RUNSIGNEDSHIFT:
1555 t = jj_consume_token(RUNSIGNEDSHIFT);
1556 break;
1557 case RUNSIGNEDSHIFTX:
1558 t = jj_consume_token(RUNSIGNEDSHIFTX);
1559 break;
1560 default:
1561 jj_consume_token(-1);
1562 throw new ParseException();
1563 }
1564 AdditiveExpression();
1565 BSHBinaryExpression jjtn001 = new BSHBinaryExpression(JJTBINARYEXPRESSION);
1566 boolean jjtc001 = true;
1567 jjtree.openNodeScope(jjtn001);
1568 jjtreeOpenNodeScope(jjtn001);
1569 try {
1570 jjtree.closeNodeScope(jjtn001, 2);
1571 jjtc001 = false;
1572 jjtreeCloseNodeScope(jjtn001);
1573 jjtn001.kind = t.kind;
1574 } finally {
1575 if (jjtc001) {
1576 jjtree.closeNodeScope(jjtn001, 2);
1577 jjtreeCloseNodeScope(jjtn001);
1578 }
1579 }
1580 }
1581 }
1582
1583 final public void AdditiveExpression() throws ParseException {
1584 Token t = null;
1585 MultiplicativeExpression();
1586 label_15:
1587 while (true) {
1588 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1589 case PLUS:
1590 case MINUS:
1591 ;
1592 break;
1593 default:
1594 break label_15;
1595 }
1596 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1597 case PLUS:
1598 t = jj_consume_token(PLUS);
1599 break;
1600 case MINUS:
1601 t = jj_consume_token(MINUS);
1602 break;
1603 default:
1604 jj_consume_token(-1);
1605 throw new ParseException();
1606 }
1607 MultiplicativeExpression();
1608 BSHBinaryExpression jjtn001 = new BSHBinaryExpression(JJTBINARYEXPRESSION);
1609 boolean jjtc001 = true;
1610 jjtree.openNodeScope(jjtn001);
1611 jjtreeOpenNodeScope(jjtn001);
1612 try {
1613 jjtree.closeNodeScope(jjtn001, 2);
1614 jjtc001 = false;
1615 jjtreeCloseNodeScope(jjtn001);
1616 jjtn001.kind = t.kind;
1617 } finally {
1618 if (jjtc001) {
1619 jjtree.closeNodeScope(jjtn001, 2);
1620 jjtreeCloseNodeScope(jjtn001);
1621 }
1622 }
1623 }
1624 }
1625
1626 final public void MultiplicativeExpression() throws ParseException {
1627 Token t = null;
1628 UnaryExpression();
1629 label_16:
1630 while (true) {
1631 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1632 case STAR:
1633 case SLASH:
1634 case MOD:
1635 ;
1636 break;
1637 default:
1638 break label_16;
1639 }
1640 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1641 case STAR:
1642 t = jj_consume_token(STAR);
1643 break;
1644 case SLASH:
1645 t = jj_consume_token(SLASH);
1646 break;
1647 case MOD:
1648 t = jj_consume_token(MOD);
1649 break;
1650 default:
1651 jj_consume_token(-1);
1652 throw new ParseException();
1653 }
1654 UnaryExpression();
1655 BSHBinaryExpression jjtn001 = new BSHBinaryExpression(JJTBINARYEXPRESSION);
1656 boolean jjtc001 = true;
1657 jjtree.openNodeScope(jjtn001);
1658 jjtreeOpenNodeScope(jjtn001);
1659 try {
1660 jjtree.closeNodeScope(jjtn001, 2);
1661 jjtc001 = false;
1662 jjtreeCloseNodeScope(jjtn001);
1663 jjtn001.kind = t.kind;
1664 } finally {
1665 if (jjtc001) {
1666 jjtree.closeNodeScope(jjtn001, 2);
1667 jjtreeCloseNodeScope(jjtn001);
1668 }
1669 }
1670 }
1671 }
1672
1673 final public void UnaryExpression() throws ParseException {
1674 Token t = null;
1675 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1676 case PLUS:
1677 case MINUS:
1678 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1679 case PLUS:
1680 t = jj_consume_token(PLUS);
1681 break;
1682 case MINUS:
1683 t = jj_consume_token(MINUS);
1684 break;
1685 default:
1686 jj_consume_token(-1);
1687 throw new ParseException();
1688 }
1689 UnaryExpression();
1690 BSHUnaryExpression jjtn001 = new BSHUnaryExpression(JJTUNARYEXPRESSION);
1691 boolean jjtc001 = true;
1692 jjtree.openNodeScope(jjtn001);
1693 jjtreeOpenNodeScope(jjtn001);
1694 try {
1695 jjtree.closeNodeScope(jjtn001, 1);
1696 jjtc001 = false;
1697 jjtreeCloseNodeScope(jjtn001);
1698 jjtn001.kind = t.kind;
1699 } finally {
1700 if (jjtc001) {
1701 jjtree.closeNodeScope(jjtn001, 1);
1702 jjtreeCloseNodeScope(jjtn001);
1703 }
1704 }
1705 break;
1706 case INCR:
1707 PreIncrementExpression();
1708 break;
1709 case DECR:
1710 PreDecrementExpression();
1711 break;
1712 case BOOLEAN:
1713 case BYTE:
1714 case CHAR:
1715 case DOUBLE:
1716 case FALSE:
1717 case FLOAT:
1718 case INT:
1719 case LONG:
1720 case NEW:
1721 case NULL:
1722 case SHORT:
1723 case TRUE:
1724 case VOID:
1725 case INTEGER_LITERAL:
1726 case FLOATING_POINT_LITERAL:
1727 case CHARACTER_LITERAL:
1728 case STRING_LITERAL:
1729 case IDENTIFIER:
1730 case LPAREN:
1731 case BANG:
1732 case TILDE:
1733 UnaryExpressionNotPlusMinus();
1734 break;
1735 default:
1736 jj_consume_token(-1);
1737 throw new ParseException();
1738 }
1739 }
1740
1741 final public void PreIncrementExpression() throws ParseException {
1742 Token t = null;
1743 t = jj_consume_token(INCR);
1744 PrimaryExpression();
1745 BSHUnaryExpression jjtn001 = new BSHUnaryExpression(JJTUNARYEXPRESSION);
1746 boolean jjtc001 = true;
1747 jjtree.openNodeScope(jjtn001);
1748 jjtreeOpenNodeScope(jjtn001);
1749 try {
1750 jjtree.closeNodeScope(jjtn001, 1);
1751 jjtc001 = false;
1752 jjtreeCloseNodeScope(jjtn001);
1753 jjtn001.kind = t.kind;
1754 } finally {
1755 if (jjtc001) {
1756 jjtree.closeNodeScope(jjtn001, 1);
1757 jjtreeCloseNodeScope(jjtn001);
1758 }
1759 }
1760 }
1761
1762 final public void PreDecrementExpression() throws ParseException {
1763 Token t = null;
1764 t = jj_consume_token(DECR);
1765 PrimaryExpression();
1766 BSHUnaryExpression jjtn001 = new BSHUnaryExpression(JJTUNARYEXPRESSION);
1767 boolean jjtc001 = true;
1768 jjtree.openNodeScope(jjtn001);
1769 jjtreeOpenNodeScope(jjtn001);
1770 try {
1771 jjtree.closeNodeScope(jjtn001, 1);
1772 jjtc001 = false;
1773 jjtreeCloseNodeScope(jjtn001);
1774 jjtn001.kind = t.kind;
1775 } finally {
1776 if (jjtc001) {
1777 jjtree.closeNodeScope(jjtn001, 1);
1778 jjtreeCloseNodeScope(jjtn001);
1779 }
1780 }
1781 }
1782
1783 final public void UnaryExpressionNotPlusMinus() throws ParseException {
1784 Token t = null;
1785 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1786 case BANG:
1787 case TILDE:
1788 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1789 case TILDE:
1790 t = jj_consume_token(TILDE);
1791 break;
1792 case BANG:
1793 t = jj_consume_token(BANG);
1794 break;
1795 default:
1796 jj_consume_token(-1);
1797 throw new ParseException();
1798 }
1799 UnaryExpression();
1800 BSHUnaryExpression jjtn001 = new BSHUnaryExpression(JJTUNARYEXPRESSION);
1801 boolean jjtc001 = true;
1802 jjtree.openNodeScope(jjtn001);
1803 jjtreeOpenNodeScope(jjtn001);
1804 try {
1805 jjtree.closeNodeScope(jjtn001, 1);
1806 jjtc001 = false;
1807 jjtreeCloseNodeScope(jjtn001);
1808 jjtn001.kind = t.kind;
1809 } finally {
1810 if (jjtc001) {
1811 jjtree.closeNodeScope(jjtn001, 1);
1812 jjtreeCloseNodeScope(jjtn001);
1813 }
1814 }
1815 break;
1816 default:
1817 if (jj_2_9(2147483647)) {
1818 CastExpression();
1819 } else {
1820 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1821 case BOOLEAN:
1822 case BYTE:
1823 case CHAR:
1824 case DOUBLE:
1825 case FALSE:
1826 case FLOAT:
1827 case INT:
1828 case LONG:
1829 case NEW:
1830 case NULL:
1831 case SHORT:
1832 case TRUE:
1833 case VOID:
1834 case INTEGER_LITERAL:
1835 case FLOATING_POINT_LITERAL:
1836 case CHARACTER_LITERAL:
1837 case STRING_LITERAL:
1838 case IDENTIFIER:
1839 case LPAREN:
1840 PostfixExpression();
1841 break;
1842 default:
1843 jj_consume_token(-1);
1844 throw new ParseException();
1845 }
1846 }
1847 }
1848 }
1849
1850 final public void CastLookahead() throws ParseException {
1852 if (jj_2_10(2)) {
1853 jj_consume_token(LPAREN);
1854 PrimitiveType();
1855 } else if (jj_2_11(2147483647)) {
1856 jj_consume_token(LPAREN);
1857 AmbiguousName();
1858 jj_consume_token(LBRACKET);
1859 jj_consume_token(RBRACKET);
1860 } else {
1861 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1862 case LPAREN:
1863 jj_consume_token(LPAREN);
1864 AmbiguousName();
1865 jj_consume_token(RPAREN);
1866 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1867 case TILDE:
1868 jj_consume_token(TILDE);
1869 break;
1870 case BANG:
1871 jj_consume_token(BANG);
1872 break;
1873 case LPAREN:
1874 jj_consume_token(LPAREN);
1875 break;
1876 case IDENTIFIER:
1877 jj_consume_token(IDENTIFIER);
1878 break;
1879 case NEW:
1880 jj_consume_token(NEW);
1881 break;
1882 case FALSE:
1883 case NULL:
1884 case TRUE:
1885 case VOID:
1886 case INTEGER_LITERAL:
1887 case FLOATING_POINT_LITERAL:
1888 case CHARACTER_LITERAL:
1889 case STRING_LITERAL:
1890 Literal();
1891 break;
1892 default:
1893 jj_consume_token(-1);
1894 throw new ParseException();
1895 }
1896 break;
1897 default:
1898 jj_consume_token(-1);
1899 throw new ParseException();
1900 }
1901 }
1902 }
1903
1904 final public void PostfixExpression() throws ParseException {
1905 Token t = null;
1906 if (jj_2_12(2147483647)) {
1907 PrimaryExpression();
1908 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1909 case INCR:
1910 t = jj_consume_token(INCR);
1911 break;
1912 case DECR:
1913 t = jj_consume_token(DECR);
1914 break;
1915 default:
1916 jj_consume_token(-1);
1917 throw new ParseException();
1918 }
1919 BSHUnaryExpression jjtn001 = new BSHUnaryExpression(JJTUNARYEXPRESSION);
1920 boolean jjtc001 = true;
1921 jjtree.openNodeScope(jjtn001);
1922 jjtreeOpenNodeScope(jjtn001);
1923 try {
1924 jjtree.closeNodeScope(jjtn001, 1);
1925 jjtc001 = false;
1926 jjtreeCloseNodeScope(jjtn001);
1927 jjtn001.kind = t.kind; jjtn001.postfix = true;
1928 } finally {
1929 if (jjtc001) {
1930 jjtree.closeNodeScope(jjtn001, 1);
1931 jjtreeCloseNodeScope(jjtn001);
1932 }
1933 }
1934 } else {
1935 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1936 case BOOLEAN:
1937 case BYTE:
1938 case CHAR:
1939 case DOUBLE:
1940 case FALSE:
1941 case FLOAT:
1942 case INT:
1943 case LONG:
1944 case NEW:
1945 case NULL:
1946 case SHORT:
1947 case TRUE:
1948 case VOID:
1949 case INTEGER_LITERAL:
1950 case FLOATING_POINT_LITERAL:
1951 case CHARACTER_LITERAL:
1952 case STRING_LITERAL:
1953 case IDENTIFIER:
1954 case LPAREN:
1955 PrimaryExpression();
1956 break;
1957 default:
1958 jj_consume_token(-1);
1959 throw new ParseException();
1960 }
1961 }
1962 }
1963
1964 final public void CastExpression() throws ParseException {
1965
1966 BSHCastExpression jjtn000 = new BSHCastExpression(JJTCASTEXPRESSION);
1967 boolean jjtc000 = true;
1968 jjtree.openNodeScope(jjtn000);
1969 jjtreeOpenNodeScope(jjtn000);
1970 try {
1971 if (jj_2_13(2147483647)) {
1972 jj_consume_token(LPAREN);
1973 Type();
1974 jj_consume_token(RPAREN);
1975 UnaryExpression();
1976 } else {
1977 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1978 case LPAREN:
1979 jj_consume_token(LPAREN);
1980 Type();
1981 jj_consume_token(RPAREN);
1982 UnaryExpressionNotPlusMinus();
1983 break;
1984 default:
1985 jj_consume_token(-1);
1986 throw new ParseException();
1987 }
1988 }
1989 } catch (Throwable jjte000) {
1990 if (jjtc000) {
1991 jjtree.clearNodeScope(jjtn000);
1992 jjtc000 = false;
1993 } else {
1994 jjtree.popNode();
1995 }
1996 if (jjte000 instanceof RuntimeException ) {
1997 {if (true) throw (RuntimeException )jjte000;}
1998 }
1999 if (jjte000 instanceof ParseException) {
2000 {if (true) throw (ParseException)jjte000;}
2001 }
2002 {if (true) throw (Error )jjte000;}
2003 } finally {
2004 if (jjtc000) {
2005 jjtree.closeNodeScope(jjtn000, true);
2006 jjtreeCloseNodeScope(jjtn000);
2007 }
2008 }
2009 }
2010
2011 final public void PrimaryExpression() throws ParseException {
2012
2013 BSHPrimaryExpression jjtn000 = new BSHPrimaryExpression(JJTPRIMARYEXPRESSION);
2014 boolean jjtc000 = true;
2015 jjtree.openNodeScope(jjtn000);
2016 jjtreeOpenNodeScope(jjtn000);
2017 try {
2018 PrimaryPrefix();
2019 label_17:
2020 while (true) {
2021 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2022 case LBRACE:
2023 case LBRACKET:
2024 case DOT:
2025 ;
2026 break;
2027 default:
2028 break label_17;
2029 }
2030 PrimarySuffix();
2031 }
2032 } catch (Throwable jjte000) {
2033 if (jjtc000) {
2034 jjtree.clearNodeScope(jjtn000);
2035 jjtc000 = false;
2036 } else {
2037 jjtree.popNode();
2038 }
2039 if (jjte000 instanceof RuntimeException ) {
2040 {if (true) throw (RuntimeException )jjte000;}
2041 }
2042 if (jjte000 instanceof ParseException) {
2043 {if (true) throw (ParseException)jjte000;}
2044 }
2045 {if (true) throw (Error )jjte000;}
2046 } finally {
2047 if (jjtc000) {
2048 jjtree.closeNodeScope(jjtn000, true);
2049 jjtreeCloseNodeScope(jjtn000);
2050 }
2051 }
2052 }
2053
2054 final public void MethodInvocation() throws ParseException {
2055
2056 BSHMethodInvocation jjtn000 = new BSHMethodInvocation(JJTMETHODINVOCATION);
2057 boolean jjtc000 = true;
2058 jjtree.openNodeScope(jjtn000);
2059 jjtreeOpenNodeScope(jjtn000);
2060 try {
2061 AmbiguousName();
2062 Arguments();
2063 } catch (Throwable jjte000) {
2064 if (jjtc000) {
2065 jjtree.clearNodeScope(jjtn000);
2066 jjtc000 = false;
2067 } else {
2068 jjtree.popNode();
2069 }
2070 if (jjte000 instanceof RuntimeException ) {
2071 {if (true) throw (RuntimeException )jjte000;}
2072 }
2073 if (jjte000 instanceof ParseException) {
2074 {if (true) throw (ParseException)jjte000;}
2075 }
2076 {if (true) throw (Error )jjte000;}
2077 } finally {
2078 if (jjtc000) {
2079 jjtree.closeNodeScope(jjtn000, true);
2080 jjtreeCloseNodeScope(jjtn000);
2081 }
2082 }
2083 }
2084
2085 final public void PrimaryPrefix() throws ParseException {
2086 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2087 case FALSE:
2088 case NULL:
2089 case TRUE:
2090 case VOID:
2091 case INTEGER_LITERAL:
2092 case FLOATING_POINT_LITERAL:
2093 case CHARACTER_LITERAL:
2094 case STRING_LITERAL:
2095 Literal();
2096 break;
2097 case LPAREN:
2098 jj_consume_token(LPAREN);
2099 Expression();
2100 jj_consume_token(RPAREN);
2101 break;
2102 case NEW:
2103 AllocationExpression();
2104 break;
2105 default:
2106 if (jj_2_14(2147483647)) {
2107 MethodInvocation();
2108 } else if (jj_2_15(2147483647)) {
2109 Type();
2110 } else {
2111 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2112 case IDENTIFIER:
2113 AmbiguousName();
2114 break;
2115 default:
2116 jj_consume_token(-1);
2117 throw new ParseException();
2118 }
2119 }
2120 }
2121 }
2122
2123 final public void PrimarySuffix() throws ParseException {
2124
2125 BSHPrimarySuffix jjtn000 = new BSHPrimarySuffix(JJTPRIMARYSUFFIX);
2126 boolean jjtc000 = true;
2127 jjtree.openNodeScope(jjtn000);
2128 jjtreeOpenNodeScope(jjtn000);Token t = null;
2129 try {
2130 if (jj_2_16(2)) {
2131 jj_consume_token(DOT);
2132 jj_consume_token(CLASS);
2133 jjtree.closeNodeScope(jjtn000, true);
2134 jjtc000 = false;
2135 jjtreeCloseNodeScope(jjtn000);
2136 jjtn000.operation = BSHPrimarySuffix.CLASS;
2137 } else {
2138 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2139 case LBRACKET:
2140 jj_consume_token(LBRACKET);
2141 Expression();
2142 jj_consume_token(RBRACKET);
2143 jjtree.closeNodeScope(jjtn000, true);
2144 jjtc000 = false;
2145 jjtreeCloseNodeScope(jjtn000);
2146 jjtn000.operation = BSHPrimarySuffix.INDEX;
2147 break;
2148 case DOT:
2149 jj_consume_token(DOT);
2150 t = jj_consume_token(IDENTIFIER);
2151 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2152 case LPAREN:
2153 Arguments();
2154 break;
2155 default:
2156 ;
2157 }
2158 jjtree.closeNodeScope(jjtn000, true);
2159 jjtc000 = false;
2160 jjtreeCloseNodeScope(jjtn000);
2161 jjtn000.operation = BSHPrimarySuffix.NAME;
2162 jjtn000.field = t.image;
2163 break;
2164 case LBRACE:
2165 jj_consume_token(LBRACE);
2166 Expression();
2167 jj_consume_token(RBRACE);
2168 jjtree.closeNodeScope(jjtn000, true);
2169 jjtc000 = false;
2170 jjtreeCloseNodeScope(jjtn000);
2171 jjtn000.operation = BSHPrimarySuffix.PROPERTY;
2172 break;
2173 default:
2174 jj_consume_token(-1);
2175 throw new ParseException();
2176 }
2177 }
2178 } catch (Throwable jjte000) {
2179 if (jjtc000) {
2180 jjtree.clearNodeScope(jjtn000);
2181 jjtc000 = false;
2182 } else {
2183 jjtree.popNode();
2184 }
2185 if (jjte000 instanceof RuntimeException ) {
2186 {if (true) throw (RuntimeException )jjte000;}
2187 }
2188 if (jjte000 instanceof ParseException) {
2189 {if (true) throw (ParseException)jjte000;}
2190 }
2191 {if (true) throw (Error )jjte000;}
2192 } finally {
2193 if (jjtc000) {
2194 jjtree.closeNodeScope(jjtn000, true);
2195 jjtreeCloseNodeScope(jjtn000);
2196 }
2197 }
2198 }
2199
2200 final public void Literal() throws ParseException {
2201
2202 BSHLiteral jjtn000 = new BSHLiteral(JJTLITERAL);
2203 boolean jjtc000 = true;
2204 jjtree.openNodeScope(jjtn000);
2205 jjtreeOpenNodeScope(jjtn000);Token x;
2206 boolean b;
2207 String literal;
2208 char ch;
2209 try {
2210 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2211 case INTEGER_LITERAL:
2212 x = jj_consume_token(INTEGER_LITERAL);
2213 jjtree.closeNodeScope(jjtn000, true);
2214 jjtc000 = false;
2215 jjtreeCloseNodeScope(jjtn000);
2216 literal = x.image;
2217 ch = literal.charAt(literal.length()-1);
2218 if(ch == 'l' || ch == 'L')
2219 {
2220 literal = literal.substring(0,literal.length()-1);
2221
2222 jjtn000.value = new Primitive( new Long ( literal ).longValue() );
2225 }
2226 else
2227 try {
2228 jjtn000.value = new Primitive(
2229 Integer.decode( literal ).intValue() );
2230 } catch ( NumberFormatException e ) {
2231 {if (true) throw createParseException(
2232 "Error or number too big for integer type: "+ literal );}
2233 }
2234 break;
2235 case FLOATING_POINT_LITERAL:
2236 x = jj_consume_token(FLOATING_POINT_LITERAL);
2237 jjtree.closeNodeScope(jjtn000, true);
2238 jjtc000 = false;
2239 jjtreeCloseNodeScope(jjtn000);
2240 literal = x.image;
2241 ch = literal.charAt(literal.length()-1);
2242 if(ch == 'f' || ch == 'F')
2243 {
2244 literal = literal.substring(0,literal.length()-1);
2245 jjtn000.value = new Primitive( new Float ( literal ).floatValue() );
2246 }
2247 else
2248 {
2249 if(ch == 'd' || ch == 'D')
2250 literal = literal.substring(0,literal.length()-1);
2251
2252 jjtn000.value = new Primitive( new Double ( literal ).doubleValue() );
2253 }
2254 break;
2255 case CHARACTER_LITERAL:
2256 x = jj_consume_token(CHARACTER_LITERAL);
2257 jjtree.closeNodeScope(jjtn000, true);
2258 jjtc000 = false;
2259 jjtreeCloseNodeScope(jjtn000);
2260 try {
2261 jjtn000.charSetup( x.image.substring(1, x.image.length() - 1) );
2262 } catch ( Exception e ) {
2263 {if (true) throw createParseException("Error parsing character: "+x.image);}
2264 }
2265 break;
2266 case STRING_LITERAL:
2267 x = jj_consume_token(STRING_LITERAL);
2268 jjtree.closeNodeScope(jjtn000, true);
2269 jjtc000 = false;
2270 jjtreeCloseNodeScope(jjtn000);
2271 try {
2272 jjtn000.stringSetup( x.image.substring(1, x.image.length() - 1) );
2273 } catch ( Exception e ) {
2274 {if (true) throw createParseException("Error parsing string: "+x.image);}
2275 }
2276 break;
2277 case FALSE:
2278 case TRUE:
2279 b = BooleanLiteral();
2280 jjtree.closeNodeScope(jjtn000, true);
2281 jjtc000 = false;
2282 jjtreeCloseNodeScope(jjtn000);
2283 jjtn000.value = new Primitive( b );
2284 break;
2285 case NULL:
2286 NullLiteral();
2287 jjtree.closeNodeScope(jjtn000, true);
2288 jjtc000 = false;
2289 jjtreeCloseNodeScope(jjtn000);
2290 jjtn000.value = Primitive.NULL;
2291 break;
2292 case VOID:
2293 VoidLiteral();
2294 jjtree.closeNodeScope(jjtn000, true);
2295 jjtc000 = false;
2296 jjtreeCloseNodeScope(jjtn000);
2297 jjtn000.value = Primitive.VOID;
2298 break;
2299 default:
2300 jj_consume_token(-1);
2301 throw new ParseException();
2302 }
2303 } catch (Throwable jjte000) {
2304 if (jjtc000) {
2305 jjtree.clearNodeScope(jjtn000);
2306 jjtc000 = false;
2307 } else {
2308 jjtree.popNode();
2309 }
2310 if (jjte000 instanceof RuntimeException ) {
2311 {if (true) throw (RuntimeException )jjte000;}
2312 }
2313 if (jjte000 instanceof ParseException) {
2314 {if (true) throw (ParseException)jjte000;}
2315 }
2316 {if (true) throw (Error )jjte000;}
2317 } finally {
2318 if (jjtc000) {
2319 jjtree.closeNodeScope(jjtn000, true);
2320 jjtreeCloseNodeScope(jjtn000);
2321 }
2322 }
2323 }
2324
2325 final public boolean BooleanLiteral() throws ParseException {
2326 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2327 case TRUE:
2328 jj_consume_token(TRUE);
2329 {if (true) return true;}
2330 break;
2331 case FALSE:
2332 jj_consume_token(FALSE);
2333 {if (true) return false;}
2334 break;
2335 default:
2336 jj_consume_token(-1);
2337 throw new ParseException();
2338 }
2339 throw new Error ("Missing return statement in function");
2340 }
2341
2342 final public void NullLiteral() throws ParseException {
2343 jj_consume_token(NULL);
2344 }
2345
2346 final public void VoidLiteral() throws ParseException {
2347 jj_consume_token(VOID);
2348 }
2349
2350 final public void Arguments() throws ParseException {
2351
2352 BSHArguments jjtn000 = new BSHArguments(JJTARGUMENTS);
2353 boolean jjtc000 = true;
2354 jjtree.openNodeScope(jjtn000);
2355 jjtreeOpenNodeScope(jjtn000);
2356 try {
2357 jj_consume_token(LPAREN);
2358 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2359 case BOOLEAN:
2360 case BYTE:
2361 case CHAR:
2362 case DOUBLE:
2363 case FALSE:
2364 case FLOAT:
2365 case INT:
2366 case LONG:
2367 case NEW:
2368 case NULL:
2369 case SHORT:
2370 case TRUE:
2371 case VOID:
2372 case INTEGER_LITERAL:
2373 case FLOATING_POINT_LITERAL:
2374 case CHARACTER_LITERAL:
2375 case STRING_LITERAL:
2376 case IDENTIFIER:
2377 case LPAREN:
2378 case BANG:
2379 case TILDE:
2380 case INCR:
2381 case DECR:
2382 case PLUS:
2383 case MINUS:
2384 ArgumentList();
2385 break;
2386 default:
2387 ;
2388 }
2389 jj_consume_token(RPAREN);
2390 } catch (Throwable jjte000) {
2391 if (jjtc000) {
2392 jjtree.clearNodeScope(jjtn000);
2393 jjtc000 = false;
2394 } else {
2395 jjtree.popNode();
2396 }
2397 if (jjte000 instanceof RuntimeException ) {
2398 {if (true) throw (RuntimeException )jjte000;}
2399 }
2400 if (jjte000 instanceof ParseException) {
2401 {if (true) throw (ParseException)jjte000;}
2402 }
2403 {if (true) throw (Error )jjte000;}
2404 } finally {
2405 if (jjtc000) {
2406 jjtree.closeNodeScope(jjtn000, true);
2407 jjtreeCloseNodeScope(jjtn000);
2408 }
2409 }
2410 }
2411
2412 final public void ArgumentList() throws ParseException {
2414 Expression();
2415 label_18:
2416 while (true) {
2417 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2418 case COMMA:
2419 ;
2420 break;
2421 default:
2422 break label_18;
2423 }
2424 jj_consume_token(COMMA);
2425 Expression();
2426 }
2427 }
2428
2429 final public void AllocationExpression() throws ParseException {
2430
2431 BSHAllocationExpression jjtn000 = new BSHAllocationExpression(JJTALLOCATIONEXPRESSION);
2432 boolean jjtc000 = true;
2433 jjtree.openNodeScope(jjtn000);
2434 jjtreeOpenNodeScope(jjtn000);
2435 try {
2436 if (jj_2_18(2)) {
2437 jj_consume_token(NEW);
2438 PrimitiveType();
2439 ArrayDimensions();
2440 } else {
2441 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2442 case NEW:
2443 jj_consume_token(NEW);
2444 AmbiguousName();
2445 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2446 case LBRACKET:
2447 ArrayDimensions();
2448 break;
2449 case LPAREN:
2450 Arguments();
2451 if (jj_2_17(2)) {
2452 Block();
2453 } else {
2454 ;
2455 }
2456 break;
2457 default:
2458 jj_consume_token(-1);
2459 throw new ParseException();
2460 }
2461 break;
2462 default:
2463 jj_consume_token(-1);
2464 throw new ParseException();
2465 }
2466 }
2467 } catch (Throwable jjte000) {
2468 if (jjtc000) {
2469 jjtree.clearNodeScope(jjtn000);
2470 jjtc000 = false;
2471 } else {
2472 jjtree.popNode();
2473 }
2474 if (jjte000 instanceof RuntimeException ) {
2475 {if (true) throw (RuntimeException )jjte000;}
2476 }
2477 if (jjte000 instanceof ParseException) {
2478 {if (true) throw (ParseException)jjte000;}
2479 }
2480 {if (true) throw (Error )jjte000;}
2481 } finally {
2482 if (jjtc000) {
2483 jjtree.closeNodeScope(jjtn000, true);
2484 jjtreeCloseNodeScope(jjtn000);
2485 }
2486 }
2487 }
2488
2489 final public void ArrayDimensions() throws ParseException {
2490
2491 BSHArrayDimensions jjtn000 = new BSHArrayDimensions(JJTARRAYDIMENSIONS);
2492 boolean jjtc000 = true;
2493 jjtree.openNodeScope(jjtn000);
2494 jjtreeOpenNodeScope(jjtn000);
2495 try {
2496 if (jj_2_21(2)) {
2497 label_19:
2498 while (true) {
2499 jj_consume_token(LBRACKET);
2500 Expression();
2501 jj_consume_token(RBRACKET);
2502 jjtn000.addDefinedDimension();
2503 if (jj_2_19(2)) {
2504 ;
2505 } else {
2506 break label_19;
2507 }
2508 }
2509 label_20:
2510 while (true) {
2511 if (jj_2_20(2)) {
2512 ;
2513 } else {
2514 break label_20;
2515 }
2516 jj_consume_token(LBRACKET);
2517 jj_consume_token(RBRACKET);
2518 jjtn000.addUndefinedDimension();
2519 }
2520 } else {
2521 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2522 case LBRACKET:
2523 label_21:
2524 while (true) {
2525 jj_consume_token(LBRACKET);
2526 jj_consume_token(RBRACKET);
2527 jjtn000.addUndefinedDimension();
2528 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2529 case LBRACKET:
2530 ;
2531 break;
2532 default:
2533 break label_21;
2534 }
2535 }
2536 ArrayInitializer();
2537 break;
2538 default:
2539 jj_consume_token(-1);
2540 throw new ParseException();
2541 }
2542 }
2543 } catch (Throwable jjte000) {
2544 if (jjtc000) {
2545 jjtree.clearNodeScope(jjtn000);
2546 jjtc000 = false;
2547 } else {
2548 jjtree.popNode();
2549 }
2550 if (jjte000 instanceof RuntimeException ) {
2551 {if (true) throw (RuntimeException )jjte000;}
2552 }
2553 if (jjte000 instanceof ParseException) {
2554 {if (true) throw (ParseException)jjte000;}
2555 }
2556 {if (true) throw (Error )jjte000;}
2557 } finally {
2558 if (jjtc000) {
2559 jjtree.closeNodeScope(jjtn000, true);
2560 jjtreeCloseNodeScope(jjtn000);
2561 }
2562 }
2563 }
2564
2565
2568 final public void Statement() throws ParseException {
2569 if (jj_2_22(2)) {
2570 LabeledStatement();
2571 } else {
2572 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2573 case LBRACE:
2574 Block();
2575 break;
2576 case SEMICOLON:
2577 EmptyStatement();
2578 break;
2579 case BOOLEAN:
2580 case BYTE:
2581 case CHAR:
2582 case DOUBLE:
2583 case FALSE:
2584 case FLOAT:
2585 case INT:
2586 case LONG:
2587 case NEW:
2588 case NULL:
2589 case SHORT:
2590 case TRUE:
2591 case VOID:
2592 case INTEGER_LITERAL:
2593 case FLOATING_POINT_LITERAL:
2594 case CHARACTER_LITERAL:
2595 case STRING_LITERAL:
2596 case IDENTIFIER:
2597 case LPAREN:
2598 case BANG:
2599 case TILDE:
2600 case INCR:
2601 case DECR:
2602 case PLUS:
2603 case MINUS:
2604 StatementExpression();
2605 jj_consume_token(SEMICOLON);
2606 break;
2607 case SWITCH:
2608 SwitchStatement();
2609 break;
2610 case IF:
2611 IfStatement();
2612 break;
2613 case WHILE:
2614 WhileStatement();
2615 break;
2616 case DO:
2617 DoStatement();
2618 break;
2619 default:
2620 if (isRegularForStatement()) {
2621 ForStatement();
2622 } else {
2623 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2624 case FOR:
2625 EnhancedForStatement();
2626 break;
2627 case BREAK:
2628 BreakStatement();
2629 break;
2630 case CONTINUE:
2631 ContinueStatement();
2632 break;
2633 case RETURN:
2634 ReturnStatement();
2635 break;
2636 case SYNCHRONIZED:
2637 SynchronizedStatement();
2638 break;
2639 case THROW:
2640 ThrowStatement();
2641 break;
2642 case TRY:
2643 TryStatement();
2644 break;
2645 default:
2646 jj_consume_token(-1);
2647 throw new ParseException();
2648 }
2649 }
2650 }
2651 }
2652 }
2653
2654 final public void LabeledStatement() throws ParseException {
2655 jj_consume_token(IDENTIFIER);
2656 jj_consume_token(COLON);
2657 Statement();
2658 }
2659
2660 final public void Block() throws ParseException {
2661
2662 BSHBlock jjtn000 = new BSHBlock(JJTBLOCK);
2663 boolean jjtc000 = true;
2664 jjtree.openNodeScope(jjtn000);
2665 jjtreeOpenNodeScope(jjtn000);
2666 try {
2667 jj_consume_token(LBRACE);
2668 label_22:
2669 while (true) {
2670 if (jj_2_23(1)) {
2671 ;
2672 } else {
2673 break label_22;
2674 }
2675 BlockStatement();
2676 }
2677 jj_consume_token(RBRACE);
2678 } catch (Throwable jjte000) {
2679 if (jjtc000) {
2680 jjtree.clearNodeScope(jjtn000);
2681 jjtc000 = false;
2682 } else {
2683 jjtree.popNode();
2684 }
2685 if (jjte000 instanceof RuntimeException ) {
2686 {if (true) throw (RuntimeException )jjte000;}
2687 }
2688 if (jjte000 instanceof ParseException) {
2689 {if (true) throw (ParseException)jjte000;}
2690 }
2691 {if (true) throw (Error )jjte000;}
2692 } finally {
2693 if (jjtc000) {
2694 jjtree.closeNodeScope(jjtn000, true);
2695 jjtreeCloseNodeScope(jjtn000);
2696 }
2697 }
2698 }
2699
2700 final public void BlockStatement() throws ParseException {
2701 if (jj_2_24(2147483647)) {
2702 ClassDeclaration();
2703 } else if (jj_2_25(2147483647)) {
2704 MethodDeclaration();
2705 } else if (jj_2_26(2147483647)) {
2706 MethodDeclaration();
2707 } else if (jj_2_27(2147483647)) {
2708 TypedVariableDeclaration();
2709 jj_consume_token(SEMICOLON);
2710 } else if (jj_2_28(1)) {
2711 Statement();
2712 } else {
2713 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2714 case IMPORT:
2715 case STATIC:
2716 ImportDeclaration();
2717 break;
2718 case PACKAGE:
2719 PackageDeclaration();
2720 break;
2721 case FORMAL_COMMENT:
2722 FormalComment();
2723 break;
2724 default:
2725 jj_consume_token(-1);
2726 throw new ParseException();
2727 }
2728 }
2729 }
2730
2731 final public void FormalComment() throws ParseException {
2732
2733 BSHFormalComment jjtn000 = new BSHFormalComment(JJTFORMALCOMMENT);
2734 boolean jjtc000 = true;
2735 jjtree.openNodeScope(jjtn000);
2736 jjtreeOpenNodeScope(jjtn000);Token t;
2737 try {
2738 t = jj_consume_token(FORMAL_COMMENT);
2739 jjtree.closeNodeScope(jjtn000, retainComments);
2740 jjtc000 = false;
2741 jjtreeCloseNodeScope(jjtn000);
2742 jjtn000.text=t.image;
2743 } finally {
2744 if (jjtc000) {
2745 jjtree.closeNodeScope(jjtn000, retainComments);
2746 jjtreeCloseNodeScope(jjtn000);
2747 }
2748 }
2749 }
2750
2751 final public void EmptyStatement() throws ParseException {
2752 jj_consume_token(SEMICOLON);
2753 }
2754
2755 final public void StatementExpression() throws ParseException {
2756 Expression();
2757 }
2758
2759 final public void SwitchStatement() throws ParseException {
2760
2761 BSHSwitchStatement jjtn000 = new BSHSwitchStatement(JJTSWITCHSTATEMENT);
2762 boolean jjtc000 = true;
2763 jjtree.openNodeScope(jjtn000);
2764 jjtreeOpenNodeScope(jjtn000);
2765 try {
2766 jj_consume_token(SWITCH);
2767 jj_consume_token(LPAREN);
2768 Expression();
2769 jj_consume_token(RPAREN);
2770 jj_consume_token(LBRACE);
2771 label_23:
2772 while (true) {
2773 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2774 case CASE:
2775 case _DEFAULT:
2776 ;
2777 break;
2778 default:
2779 break label_23;
2780 }
2781 SwitchLabel();
2782 label_24:
2783 while (true) {
2784 if (jj_2_29(1)) {
2785 ;
2786 } else {
2787 break label_24;
2788 }
2789 BlockStatement();
2790 }
2791 }
2792 jj_consume_token(RBRACE);
2793 } catch (Throwable jjte000) {
2794 if (jjtc000) {
2795 jjtree.clearNodeScope(jjtn000);
2796 jjtc000 = false;
2797 } else {
2798 jjtree.popNode();
2799 }
2800 if (jjte000 instanceof RuntimeException ) {
2801 {if (true) throw (RuntimeException )jjte000;}
2802 }
2803 if (jjte000 instanceof ParseException) {
2804 {if (true) throw (ParseException)jjte000;}
2805 }
2806 {if (true) throw (Error )jjte000;}
2807 } finally {
2808 if (jjtc000) {
2809 jjtree.closeNodeScope(jjtn000, true);
2810 jjtreeCloseNodeScope(jjtn000);
2811 }
2812 }
2813 }
2814
2815 final public void SwitchLabel() throws ParseException {
2816
2817 BSHSwitchLabel jjtn000 = new BSHSwitchLabel(JJTSWITCHLABEL);
2818 boolean jjtc000 = true;
2819 jjtree.openNodeScope(jjtn000);
2820 jjtreeOpenNodeScope(jjtn000);
2821 try {
2822 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2823 case CASE:
2824 jj_consume_token(CASE);
2825 Expression();
2826 jj_consume_token(COLON);
2827 break;
2828 case _DEFAULT:
2829 jj_consume_token(_DEFAULT);
2830 jj_consume_token(COLON);
2831 jjtree.closeNodeScope(jjtn000, true);
2832 jjtc000 = false;
2833 jjtreeCloseNodeScope(jjtn000);
2834 jjtn000.isDefault = true;
2835 break;
2836 default:
2837 jj_consume_token(-1);
2838 throw new ParseException();
2839 }
2840 } catch (Throwable jjte000) {
2841 if (jjtc000) {
2842 jjtree.clearNodeScope(jjtn000);
2843 jjtc000 = false;
2844 } else {
2845 jjtree.popNode();
2846 }
2847 if (jjte000 instanceof RuntimeException ) {
2848 {if (true) throw (RuntimeException )jjte000;}
2849 }
2850 if (jjte000 instanceof ParseException) {
2851 {if (true) throw (ParseException)jjte000;}
2852 }
2853 {if (true) throw (Error )jjte000;}
2854 } finally {
2855 if (jjtc000) {
2856 jjtree.closeNodeScope(jjtn000, true);
2857 jjtreeCloseNodeScope(jjtn000);
2858 }
2859 }
2860 }
2861
2862 final public void IfStatement() throws ParseException {
2863
2864 BSHIfStatement jjtn000 = new BSHIfStatement(JJTIFSTATEMENT);
2865 boolean jjtc000 = true;
2866 jjtree.openNodeScope(jjtn000);
2867 jjtreeOpenNodeScope(jjtn000);
2868 try {
2869 jj_consume_token(IF);
2870 jj_consume_token(LPAREN);
2871 Expression();
2872 jj_consume_token(RPAREN);
2873 Statement();
2874 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2875 case ELSE:
2876 jj_consume_token(ELSE);
2877 Statement();
2878 break;
2879 default:
2880 ;
2881 }
2882 } catch (Throwable jjte000) {
2883 if (jjtc000) {
2884 jjtree.clearNodeScope(jjtn000);
2885 jjtc000 = false;
2886 } else {
2887 jjtree.popNode();
2888 }
2889 if (jjte000 instanceof RuntimeException ) {
2890 {if (true) throw (RuntimeException )jjte000;}
2891 }
2892 if (jjte000 instanceof ParseException) {
2893 {if (true) throw (ParseException)jjte000;}
2894 }
2895 {if (true) throw (Error )jjte000;}
2896 } finally {
2897 if (jjtc000) {
2898 jjtree.closeNodeScope(jjtn000, true);
2899 jjtreeCloseNodeScope(jjtn000);
2900 }
2901 }
2902 }
2903
2904 final public void WhileStatement() throws ParseException {
2905
2906 BSHWhileStatement jjtn000 = new BSHWhileStatement(JJTWHILESTATEMENT);
2907 boolean jjtc000 = true;
2908 jjtree.openNodeScope(jjtn000);
2909 jjtreeOpenNodeScope(jjtn000);
2910 try {
2911 jj_consume_token(WHILE);
2912 jj_consume_token(LPAREN);
2913 Expression();
2914 jj_consume_token(RPAREN);
2915 Statement();
2916 } catch (Throwable jjte000) {
2917 if (jjtc000) {
2918 jjtree.clearNodeScope(jjtn000);
2919 jjtc000 = false;
2920 } else {
2921 jjtree.popNode();
2922 }
2923 if (jjte000 instanceof RuntimeException ) {
2924 {if (true) throw (RuntimeException )jjte000;}
2925 }
2926 if (jjte000 instanceof ParseException) {
2927 {if (true) throw (ParseException)jjte000;}
2928 }
2929 {if (true) throw (Error )jjte000;}
2930 } finally {
2931 if (jjtc000) {
2932 jjtree.closeNodeScope(jjtn000, true);
2933 jjtreeCloseNodeScope(jjtn000);
2934 }
2935 }
2936 }
2937
2938
2942 final public void DoStatement() throws ParseException {
2943
2944 BSHWhileStatement jjtn000 = new BSHWhileStatement(JJTWHILESTATEMENT);
2945 boolean jjtc000 = true;
2946 jjtree.openNodeScope(jjtn000);
2947 jjtreeOpenNodeScope(jjtn000);
2948 try {
2949 jj_consume_token(DO);
2950 Statement();
2951 jj_consume_token(WHILE);
2952 jj_consume_token(LPAREN);
2953 Expression();
2954 jj_consume_token(RPAREN);
2955 jj_consume_token(SEMICOLON);
2956 jjtree.closeNodeScope(jjtn000, true);
2957 jjtc000 = false;
2958 jjtreeCloseNodeScope(jjtn000);
2959 jjtn000.isDoStatement=true;
2960 } catch (Throwable jjte000) {
2961 if (jjtc000) {
2962 jjtree.clearNodeScope(jjtn000);
2963 jjtc000 = false;
2964 } else {
2965 jjtree.popNode();
2966 }
2967 if (jjte000 instanceof RuntimeException ) {
2968 {if (true) throw (RuntimeException )jjte000;}
2969 }
2970 if (jjte000 instanceof ParseException) {
2971 {if (true) throw (ParseException)jjte000;}
2972 }
2973 {if (true) throw (Error )jjte000;}
2974 } finally {
2975 if (jjtc000) {
2976 jjtree.closeNodeScope(jjtn000, true);
2977 jjtreeCloseNodeScope(jjtn000);
2978 }
2979 }
2980 }
2981
2982 final public void ForStatement() throws ParseException {
2983
2984 BSHForStatement jjtn000 = new BSHForStatement(JJTFORSTATEMENT);
2985 boolean jjtc000 = true;
2986 jjtree.openNodeScope(jjtn000);
2987 jjtreeOpenNodeScope(jjtn000);Token t = null;
2988 try {
2989 jj_consume_token(FOR);
2990 jj_consume_token(LPAREN);
2991 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2992 case ABSTRACT:
2993 case BOOLEAN:
2994 case BYTE:
2995 case CHAR:
2996 case DOUBLE:
2997 case FALSE:
2998 case FINAL:
2999 case FLOAT:
3000 case INT:
3001 case LONG:
3002 case NATIVE:
3003 case NEW:
3004 case NULL:
3005 case PRIVATE:
3006 case PROTECTED:
3007 case PUBLIC:
3008 case SHORT:
3009 case STATIC:
3010 case STRICTFP:
3011 case SYNCHRONIZED:
3012 case TRANSIENT:
3013 case TRUE:
3014 case VOID:
3015 case VOLATILE:
3016 case INTEGER_LITERAL:
3017 case FLOATING_POINT_LITERAL:
3018 case CHARACTER_LITERAL:
3019 case STRING_LITERAL:
3020 case IDENTIFIER:
3021 case LPAREN:
3022 case BANG:
3023 case TILDE:
3024 case INCR:
3025 case DECR:
3026 case PLUS:
3027 case MINUS:
3028 ForInit();
3029 jjtn000.hasForInit=true;
3030 break;
3031 default:
3032 ;
3033 }
3034 jj_consume_token(SEMICOLON);
3035 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3036 case BOOLEAN:
3037 case BYTE:
3038 case CHAR:
3039 case DOUBLE:
3040 case FALSE:
3041 case FLOAT:
3042 case INT:
3043 case LONG:
3044 case NEW:
3045 case NULL:
3046 case SHORT:
3047 case TRUE:
3048 case VOID:
3049 case INTEGER_LITERAL:
3050 case FLOATING_POINT_LITERAL:
3051 case CHARACTER_LITERAL:
3052 case STRING_LITERAL:
3053 case IDENTIFIER:
3054 case LPAREN:
3055 case BANG:
3056 case TILDE:
3057 case INCR:
3058 case DECR:
3059 case PLUS:
3060 case MINUS:
3061 Expression();
3062 jjtn000.hasExpression=true;
3063 break;
3064 default:
3065 ;
3066 }
3067 jj_consume_token(SEMICOLON);
3068 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3069 case BOOLEAN:
3070 case BYTE:
3071 case CHAR:
3072 case DOUBLE:
3073 case FALSE:
3074 case FLOAT:
3075 case INT:
3076 case LONG:
3077 case NEW:
3078 case NULL:
3079 case SHORT:
3080 case TRUE:
3081 case VOID:
3082 case INTEGER_LITERAL:
3083 case FLOATING_POINT_LITERAL:
3084 case CHARACTER_LITERAL:
3085 case STRING_LITERAL:
3086 case IDENTIFIER:
3087 case LPAREN:
3088 case BANG:
3089 case TILDE:
3090 case INCR:
3091 case DECR:
3092 case PLUS:
3093 case MINUS:
3094 ForUpdate();
3095 jjtn000.hasForUpdate=true;
3096 break;
3097 default:
3098 ;
3099 }
3100 jj_consume_token(RPAREN);
3101 Statement();
3102 } catch (Throwable jjte000) {
3103 if (jjtc000) {
3104 jjtree.clearNodeScope(jjtn000);
3105 jjtc000 = false;
3106 } else {
3107 jjtree.popNode();
3108 }
3109 if (jjte000 instanceof RuntimeException ) {
3110 {if (true) throw (RuntimeException )jjte000;}
3111 }
3112 if (jjte000 instanceof ParseException) {
3113 {if (true) throw (ParseException)jjte000;}
3114 }
3115 {if (true) throw (Error )jjte000;}
3116 } finally {
3117 if (jjtc000) {
3118 jjtree.closeNodeScope(jjtn000, true);
3119 jjtreeCloseNodeScope(jjtn000);
3120 }
3121 }
3122 }
3123
3124
3130 final public void EnhancedForStatement() throws ParseException {
3131
3132 BSHEnhancedForStatement jjtn000 = new BSHEnhancedForStatement(JJTENHANCEDFORSTATEMENT);
3133 boolean jjtc000 = true;
3134 jjtree.openNodeScope(jjtn000);
3135 jjtreeOpenNodeScope(jjtn000);Token t = null;
3136 try {
3137 if (jj_2_30(4)) {
3138 jj_consume_token(FOR);
3139 jj_consume_token(LPAREN);
3140 t = jj_consume_token(IDENTIFIER);
3141 jj_consume_token(COLON);
3142 Expression();
3143 jj_consume_token(RPAREN);
3144 Statement();
3145 jjtree.closeNodeScope(jjtn000, true);
3146 jjtc000 = false;
3147 jjtreeCloseNodeScope(jjtn000);
3148 jjtn000.varName = t.image;
3149 } else {
3150 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3151 case FOR:
3152 jj_consume_token(FOR);
3153 jj_consume_token(LPAREN);
3154 Type();
3155 t = jj_consume_token(IDENTIFIER);
3156 jj_consume_token(COLON);
3157 Expression();
3158 jj_consume_token(RPAREN);
3159 Statement();
3160 jjtree.closeNodeScope(jjtn000, true);
3161 jjtc000 = false;
3162 jjtreeCloseNodeScope(jjtn000);
3163 jjtn000.varName = t.image;
3164 break;
3165 default:
3166 jj_consume_token(-1);
3167 throw new ParseException();
3168 }
3169 }
3170 } catch (Throwable jjte000) {
3171 if (jjtc000) {
3172 jjtree.clearNodeScope(jjtn000);
3173 jjtc000 = false;
3174 } else {
3175 jjtree.popNode();
3176 }
3177 if (jjte000 instanceof RuntimeException ) {
3178 {if (true) throw (RuntimeException )jjte000;}
3179 }
3180 if (jjte000 instanceof ParseException) {
3181 {if (true) throw (ParseException)jjte000;}
3182 }
3183 {if (true) throw (Error )jjte000;}
3184 } finally {
3185 if (jjtc000) {
3186 jjtree.closeNodeScope(jjtn000, true);
3187 jjtreeCloseNodeScope(jjtn000);
3188 }
3189 }
3190 }
3191
3192 final public void ForInit() throws ParseException {
3193 Token t = null;
3194 if (jj_2_31(2147483647)) {
3195 TypedVariableDeclaration();
3196 } else {
3197 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3198 case BOOLEAN:
3199 case BYTE:
3200 case CHAR:
3201 case DOUBLE:
3202 case FALSE:
3203 case FLOAT:
3204 case INT:
3205 case LONG:
3206 case NEW:
3207 case NULL:
3208 case SHORT:
3209 case TRUE:
3210 case VOID:
3211 case INTEGER_LITERAL:
3212 case FLOATING_POINT_LITERAL:
3213 case CHARACTER_LITERAL:
3214 case STRING_LITERAL:
3215 case IDENTIFIER:
3216 case LPAREN:
3217 case BANG:
3218 case TILDE:
3219 case INCR:
3220 case DECR:
3221 case PLUS:
3222 case MINUS:
3223 StatementExpressionList();
3224 break;
3225 default:
3226 jj_consume_token(-1);
3227 throw new ParseException();
3228 }
3229 }
3230 }
3231
3232
3237 final public void TypedVariableDeclaration() throws ParseException {
3238
3239 BSHTypedVariableDeclaration jjtn000 = new BSHTypedVariableDeclaration(JJTTYPEDVARIABLEDECLARATION);
3240 boolean jjtc000 = true;
3241 jjtree.openNodeScope(jjtn000);
3242 jjtreeOpenNodeScope(jjtn000);Token t = null;
3243 Modifiers mods;
3244 try {
3245 mods = Modifiers(Modifiers.FIELD, false);
3246 Type();
3247 VariableDeclarator();
3248 label_25:
3249 while (true) {
3250 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3251 case COMMA:
3252 ;
3253 break;
3254 default:
3255 break label_25;
3256 }
3257 jj_consume_token(COMMA);
3258 VariableDeclarator();
3259 }
3260 jjtree.closeNodeScope(jjtn000, true);
3261 jjtc000 = false;
3262 jjtreeCloseNodeScope(jjtn000);
3263 jjtn000.modifiers = mods;
3264 } catch (Throwable jjte000) {
3265 if (jjtc000) {
3266 jjtree.clearNodeScope(jjtn000);
3267 jjtc000 = false;
3268 } else {
3269 jjtree.popNode();
3270 }
3271 if (jjte000 instanceof RuntimeException ) {
3272 {if (true) throw (RuntimeException )jjte000;}
3273 }
3274 if (jjte000 instanceof ParseException) {
3275 {if (true) throw (ParseException)jjte000;}
3276 }
3277 {if (true) throw (Error )jjte000;}
3278 } finally {
3279 if (jjtc000) {
3280 jjtree.closeNodeScope(jjtn000, true);
3281 jjtreeCloseNodeScope(jjtn000);
3282 }
3283 }
3284 }
3285
3286 final public void StatementExpressionList() throws ParseException {
3287
3288 BSHStatementExpressionList jjtn000 = new BSHStatementExpressionList(JJTSTATEMENTEXPRESSIONLIST);
3289 boolean jjtc000 = true;
3290 jjtree.openNodeScope(jjtn000);
3291 jjtreeOpenNodeScope(jjtn000);
3292 try {
3293 StatementExpression();
3294 label_26:
3295 while (true) {
3296 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3297 case COMMA:
3298 ;
3299 break;
3300 default:
3301 break label_26;
3302 }
3303 jj_consume_token(COMMA);
3304 StatementExpression();
3305 }
3306 } catch (Throwable jjte000) {
3307 if (jjtc000) {
3308 jjtree.clearNodeScope(jjtn000);
3309 jjtc000 = false;
3310 } else {
3311 jjtree.popNode();
3312 }
3313 if (jjte000 instanceof RuntimeException ) {
3314 {if (true) throw (RuntimeException )jjte000;}
3315 }
3316 if (jjte000 instanceof ParseException) {
3317 {if (true) throw (ParseException)jjte000;}
3318 }
3319 {if (true) throw (Error )jjte000;}
3320 } finally {
3321 if (jjtc000) {
3322 jjtree.closeNodeScope(jjtn000, true);
3323 jjtreeCloseNodeScope(jjtn000);
3324 }
3325 }
3326 }
3327
3328 final public void ForUpdate() throws ParseException {
3329 StatementExpressionList();
3330 }
3331
3332 final public void BreakStatement() throws ParseException {
3333
3334 BSHReturnStatement jjtn000 = new BSHReturnStatement(JJTRETURNSTATEMENT);
3335 boolean jjtc000 = true;
3336 jjtree.openNodeScope(jjtn000);
3337 jjtreeOpenNodeScope(jjtn000);
3338 try {
3339 jj_consume_token(BREAK);
3340 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3341 case IDENTIFIER:
3342 jj_consume_token(IDENTIFIER);
3343 break;
3344 default:
3345 ;
3346 }
3347 jj_consume_token(SEMICOLON);
3348 jjtree.closeNodeScope(jjtn000, true);
3349 jjtc000 = false;
3350 jjtreeCloseNodeScope(jjtn000);
3351 jjtn000.kind = BREAK;
3352 } finally {
3353 if (jjtc000) {
3354 jjtree.closeNodeScope(jjtn000, true);
3355 jjtreeCloseNodeScope(jjtn000);
3356 }
3357 }
3358 }
3359
3360 final public void ContinueStatement() throws ParseException {
3361
3362 BSHReturnStatement jjtn000 = new BSHReturnStatement(JJTRETURNSTATEMENT);
3363 boolean jjtc000 = true;
3364 jjtree.openNodeScope(jjtn000);
3365 jjtreeOpenNodeScope(jjtn000);
3366 try {
3367 jj_consume_token(CONTINUE);
3368 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3369 case IDENTIFIER:
3370 jj_consume_token(IDENTIFIER);
3371 break;
3372 default:
3373 ;
3374 }
3375 jj_consume_token(SEMICOLON);
3376 jjtree.closeNodeScope(jjtn000, true);
3377 jjtc000 = false;
3378 jjtreeCloseNodeScope(jjtn000);
3379 jjtn000.kind = CONTINUE;
3380 } finally {
3381 if (jjtc000) {
3382 jjtree.closeNodeScope(jjtn000, true);
3383 jjtreeCloseNodeScope(jjtn000);
3384 }
3385 }
3386 }
3387
3388 final public void ReturnStatement() throws ParseException {
3389
3390 BSHReturnStatement jjtn000 = new BSHReturnStatement(JJTRETURNSTATEMENT);
3391 boolean jjtc000 = true;
3392 jjtree.openNodeScope(jjtn000);
3393 jjtreeOpenNodeScope(jjtn000);
3394 try {
3395 jj_consume_token(RETURN);
3396 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3397 case BOOLEAN:
3398 case BYTE:
3399 case CHAR:
3400 case DOUBLE:
3401 case FALSE:
3402 case FLOAT:
3403 case INT:
3404 case LONG:
3405 case NEW:
3406 case NULL:
3407 case SHORT:
3408 case TRUE:
3409 case VOID:
3410 case INTEGER_LITERAL:
3411 case FLOATING_POINT_LITERAL:
3412 case CHARACTER_LITERAL:
3413 case STRING_LITERAL:
3414 case IDENTIFIER:
3415 case LPAREN:
3416 case BANG:
3417 case TILDE:
3418 case INCR:
3419 case DECR:
3420 case PLUS:
3421 case MINUS:
3422 Expression();
3423 break;
3424 default:
3425 ;
3426 }
3427 jj_consume_token(SEMICOLON);
3428 jjtree.closeNodeScope(jjtn000, true);
3429 jjtc000 = false;
3430 jjtreeCloseNodeScope(jjtn000);
3431 jjtn000.kind = RETURN;
3432 } catch (Throwable jjte000) {
3433 if (jjtc000) {
3434 jjtree.clearNodeScope(jjtn000);
3435 jjtc000 = false;
3436 } else {
3437 jjtree.popNode();
3438 }
3439 if (jjte000 instanceof RuntimeException ) {
3440 {if (true) throw (RuntimeException )jjte000;}
3441 }
3442 if (jjte000 instanceof ParseException) {
3443 {if (true) throw (ParseException)jjte000;}
3444 }
3445 {if (true) throw (Error )jjte000;}
3446 } finally {
3447 if (jjtc000) {
3448 jjtree.closeNodeScope(jjtn000, true);
3449 jjtreeCloseNodeScope(jjtn000);
3450 }
3451 }
3452 }
3453
3454 final public void SynchronizedStatement() throws ParseException {
3455
3456 BSHBlock jjtn000 = new BSHBlock(JJTBLOCK);
3457 boolean jjtc000 = true;
3458 jjtree.openNodeScope(jjtn000);
3459 jjtreeOpenNodeScope(jjtn000);
3460 try {
3461 jj_consume_token(SYNCHRONIZED);
3462 jj_consume_token(LPAREN);
3463 Expression();
3464 jj_consume_token(RPAREN);
3465 Block();
3466 jjtree.closeNodeScope(jjtn000, true);
3467 jjtc000 = false;
3468 jjtreeCloseNodeScope(jjtn000);
3469 jjtn000.isSynchronized=true;
3470 } catch (Throwable jjte000) {
3471 if (jjtc000) {
3472 jjtree.clearNodeScope(jjtn000);
3473 jjtc000 = false;
3474 } else {
3475 jjtree.popNode();
3476 }
3477 if (jjte000 instanceof RuntimeException ) {
3478 {if (true) throw (RuntimeException )jjte000;}
3479 }
3480 if (jjte000 instanceof ParseException) {
3481 {if (true) throw (ParseException)jjte000;}
3482 }
3483 {if (true) throw (Error )jjte000;}
3484 } finally {
3485 if (jjtc000) {
3486 jjtree.closeNodeScope(jjtn000, true);
3487 jjtreeCloseNodeScope(jjtn000);
3488 }
3489 }
3490 }
3491
3492 final public void ThrowStatement() throws ParseException {
3493
3494 BSHThrowStatement jjtn000 = new BSHThrowStatement(JJTTHROWSTATEMENT);
3495 boolean jjtc000 = true;
3496 jjtree.openNodeScope(jjtn000);
3497 jjtreeOpenNodeScope(jjtn000);
3498 try {
3499 jj_consume_token(THROW);
3500 Expression();
3501 jj_consume_token(SEMICOLON);
3502 } catch (Throwable jjte000) {
3503 if (jjtc000) {
3504 jjtree.clearNodeScope(jjtn000);
3505 jjtc000 = false;
3506 } else {
3507 jjtree.popNode();
3508 }
3509 if (jjte000 instanceof RuntimeException ) {
3510 {if (true) throw (RuntimeException )jjte000;}
3511 }
3512 if (jjte000 instanceof ParseException) {
3513 {if (true) throw (ParseException)jjte000;}
3514 }
3515 {if (true) throw (Error )jjte000;}
3516 } finally {
3517 if (jjtc000) {
3518 jjtree.closeNodeScope(jjtn000, true);
3519 jjtreeCloseNodeScope(jjtn000);
3520 }
3521 }
3522 }
3523
3524 final public void TryStatement() throws ParseException {
3525
3526 BSHTryStatement jjtn000 = new BSHTryStatement(JJTTRYSTATEMENT);
3527 boolean jjtc000 = true;
3528 jjtree.openNodeScope(jjtn000);
3529 jjtreeOpenNodeScope(jjtn000);boolean closed = false;
3530 try {
3531 jj_consume_token(TRY);
3532 Block();
3533 label_27:
3534 while (true) {
3535 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3536 case CATCH:
3537 ;
3538 break;
3539 default:
3540 break label_27;
3541 }
3542 jj_consume_token(CATCH);
3543 jj_consume_token(LPAREN);
3544 FormalParameter();
3545 jj_consume_token(RPAREN);
3546 Block();
3547 closed = true;
3548 }
3549 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3550 case FINALLY:
3551 jj_consume_token(FINALLY);
3552 Block();
3553 closed = true;
3554 break;
3555 default:
3556 ;
3557 }
3558 jjtree.closeNodeScope(jjtn000, true);
3559 jjtc000 = false;
3560 jjtreeCloseNodeScope(jjtn000);
3561 if ( !closed ) {if (true) throw generateParseException();}
3562 } catch (Throwable jjte000) {
3563 if (jjtc000) {
3564 jjtree.clearNodeScope(jjtn000);
3565 jjtc000 = false;
3566 } else {
3567 jjtree.popNode();
3568 }
3569 if (jjte000 instanceof RuntimeException ) {
3570 {if (true) throw (RuntimeException )jjte000;}
3571 }
3572 if (jjte000 instanceof ParseException) {
3573 {if (true) throw (ParseException)jjte000;}
3574 }
3575 {if (true) throw (Error )jjte000;}
3576 } finally {
3577 if (jjtc000) {
3578 jjtree.closeNodeScope(jjtn000, true);
3579 jjtreeCloseNodeScope(jjtn000);
3580 }
3581 }
3582 }
3583
3584 final private boolean jj_2_1(int xla) {
3585 jj_la = xla; jj_lastpos = jj_scanpos = token;
3586 try { return !jj_3_1(); }
3587 catch(LookaheadSuccess ls) { return true; }
3588 }
3589
3590 final private boolean jj_2_2(int xla) {
3591 jj_la = xla; jj_lastpos = jj_scanpos = token;
3592 try { return !jj_3_2(); }
3593 catch(LookaheadSuccess ls) { return true; }
3594 }
3595
3596 final private boolean jj_2_3(int xla) {
3597 jj_la = xla; jj_lastpos = jj_scanpos = token;
3598 try { return !jj_3_3(); }
3599 catch(LookaheadSuccess ls) { return true; }
3600 }
3601
3602 final private boolean jj_2_4(int xla) {
3603 jj_la = xla; jj_lastpos = jj_scanpos = token;
3604 try { return !jj_3_4(); }
3605 catch(LookaheadSuccess ls) { return true; }
3606 }
3607
3608 final private boolean jj_2_5(int xla) {
3609 jj_la = xla; jj_lastpos = jj_scanpos = token;
3610 try { return !jj_3_5(); }
3611 catch(LookaheadSuccess ls) { return true; }
3612 }
3613
3614 final private boolean jj_2_6(int xla) {
3615 jj_la = xla; jj_lastpos = jj_scanpos = token;
3616 try { return !jj_3_6(); }
3617 catch(LookaheadSuccess ls) { return true; }
3618 }
3619
3620 final private boolean jj_2_7(int xla) {
3621 jj_la = xla; jj_lastpos = jj_scanpos = token;
3622 try { return !jj_3_7(); }
3623 catch(LookaheadSuccess ls) { return true; }
3624 }
3625
3626 final private boolean jj_2_8(int xla) {
3627 jj_la = xla; jj_lastpos = jj_scanpos = token;
3628 try { return !jj_3_8(); }
3629 catch(LookaheadSuccess ls) { return true; }
3630 }
3631
3632 final private boolean jj_2_9(int xla) {
3633 jj_la = xla; jj_lastpos = jj_scanpos = token;
3634 try { return !jj_3_9(); }
3635 catch(LookaheadSuccess ls) { return true; }
3636 }
3637
3638 final private boolean jj_2_10(int xla) {
3639 jj_la = xla; jj_lastpos = jj_scanpos = token;
3640 try { return !jj_3_10(); }
3641 catch(LookaheadSuccess ls) { return true; }
3642 }
3643
3644 final private boolean jj_2_11(int xla) {
3645 jj_la = xla; jj_lastpos = jj_scanpos = token;
3646 try { return !jj_3_11(); }
3647 catch(LookaheadSuccess ls) { return true; }
3648 }
3649
3650 final private boolean jj_2_12(int xla) {
3651 jj_la = xla; jj_lastpos = jj_scanpos = token;
3652 try { return !jj_3_12(); }
3653 catch(LookaheadSuccess ls) { return true; }
3654 }
3655
3656 final private boolean jj_2_13(int xla) {
3657 jj_la = xla; jj_lastpos = jj_scanpos = token;
3658 try { return !jj_3_13(); }
3659 catch(LookaheadSuccess ls) { return true; }
3660 }
3661
3662 final private boolean jj_2_14(int xla) {
3663 jj_la = xla; jj_lastpos = jj_scanpos = token;
3664 try { return !jj_3_14(); }
3665 catch(LookaheadSuccess ls) { return true; }
3666 }
3667
3668 final private boolean jj_2_15(int xla) {
3669 jj_la = xla; jj_lastpos = jj_scanpos = token;
3670 try { return !jj_3_15(); }
3671 catch(LookaheadSuccess ls) { return true; }
3672 }
3673
3674 final private boolean jj_2_16(int xla) {
3675 jj_la = xla; jj_lastpos = jj_scanpos = token;
3676 try { return !jj_3_16(); }
3677 catch(LookaheadSuccess ls) { return true; }
3678 }
3679
3680 final private boolean jj_2_17(int xla) {
3681 jj_la = xla; jj_lastpos = jj_scanpos = token;
3682 try { return !jj_3_17(); }
3683 catch(LookaheadSuccess ls) { return true; }
3684 }
3685
3686 final private boolean jj_2_18(int xla) {
3687 jj_la = xla; jj_lastpos = jj_scanpos = token;
3688 try { return !jj_3_18(); }
3689 catch(LookaheadSuccess ls) { return true; }
3690 }
3691
3692 final private boolean jj_2_19(int xla) {
3693 jj_la = xla; jj_lastpos = jj_scanpos = token;
3694 try { return !jj_3_19(); }
3695 catch(LookaheadSuccess ls) { return true; }
3696 }
3697
3698 final private boolean jj_2_20(int xla) {
3699 jj_la = xla; jj_lastpos = jj_scanpos = token;
3700 try { return !jj_3_20(); }
3701 catch(LookaheadSuccess ls) { return true; }
3702 }
3703
3704 final private boolean jj_2_21(int xla) {
3705 jj_la = xla; jj_lastpos = jj_scanpos = token;
3706 try { return !jj_3_21(); }
3707 catch(LookaheadSuccess ls) { return true; }
3708 }
3709
3710 final private boolean jj_2_22(int xla) {
3711 jj_la = xla; jj_lastpos = jj_scanpos = token;
3712 try { return !jj_3_22(); }
3713 catch(LookaheadSuccess ls) { return true; }
3714 }
3715
3716 final private boolean jj_2_23(int xla) {
3717 jj_la = xla; jj_lastpos = jj_scanpos = token;
3718 try { return !jj_3_23(); }
3719 catch(LookaheadSuccess ls) { return true; }
3720 }
3721
3722 final private boolean jj_2_24(int xla) {
3723 jj_la = xla; jj_lastpos = jj_scanpos = token;
3724 try { return !jj_3_24(); }
3725 catch(LookaheadSuccess ls) { return true; }
3726 }
3727
3728 final private boolean jj_2_25(int xla) {
3729 jj_la = xla; jj_lastpos = jj_scanpos = token;
3730 try { return !jj_3_25(); }
3731 catch(LookaheadSuccess ls) { return true; }
3732 }
3733
3734 final private boolean jj_2_26(int xla) {
3735 jj_la = xla; jj_lastpos = jj_scanpos = token;
3736 try { return !jj_3_26(); }
3737 catch(LookaheadSuccess ls) { return true; }
3738 }
3739
3740 final private boolean jj_2_27(int xla) {
3741 jj_la = xla; jj_lastpos = jj_scanpos = token;
3742 try { return !jj_3_27(); }
3743 catch(LookaheadSuccess ls) { return true; }
3744 }
3745
3746 final private boolean jj_2_28(int xla) {
3747 jj_la = xla; jj_lastpos = jj_scanpos = token;
3748 try { return !jj_3_28(); }
3749 catch(LookaheadSuccess ls) { return true; }
3750 }
3751
3752 final private boolean jj_2_29(int xla) {
3753 jj_la = xla; jj_lastpos = jj_scanpos = token;
3754 try { return !jj_3_29(); }
3755 catch(LookaheadSuccess ls) { return true; }
3756 }
3757
3758 final private boolean jj_2_30(int xla) {
3759 jj_la = xla; jj_lastpos = jj_scanpos = token;
3760 try { return !jj_3_30(); }
3761 catch(LookaheadSuccess ls) { return true; }
3762 }
3763
3764 final private boolean jj_2_31(int xla) {
3765 jj_la = xla; jj_lastpos = jj_scanpos = token;
3766 try { return !jj_3_31(); }
3767 catch(LookaheadSuccess ls) { return true; }
3768 }
3769
3770 final private boolean jj_3R_46() {
3771 if (jj_3R_91()) return true;
3772 return false;
3773 }
3774
3775 final private boolean jj_3R_28() {
3776 Token xsp;
3777 xsp = jj_scanpos;
3778 if (jj_3R_46()) {
3779 jj_scanpos = xsp;
3780 if (jj_3R_47()) {
3781 jj_scanpos = xsp;
3782 if (jj_3R_48()) {
3783 jj_scanpos = xsp;
3784 if (jj_3R_49()) {
3785 jj_scanpos = xsp;
3786 if (jj_3_28()) {
3787 jj_scanpos = xsp;
3788 if (jj_3R_50()) {
3789 jj_scanpos = xsp;
3790 if (jj_3R_51()) {
3791 jj_scanpos = xsp;
3792 if (jj_3R_52()) return true;
3793 }
3794 }
3795 }
3796 }
3797 }
3798 }
3799 }
3800 return false;
3801 }
3802
3803 final private boolean jj_3_23() {
3804 if (jj_3R_28()) return true;
3805 return false;
3806 }
3807
3808 final private boolean jj_3R_161() {
3809 if (jj_3R_164()) return true;
3810 Token xsp;
3811 while (true) {
3812 xsp = jj_scanpos;
3813 if (jj_3R_169()) { jj_scanpos = xsp; break; }
3814 }
3815 return false;
3816 }
3817
3818 final private boolean jj_3R_38() {
3819 if (jj_scan_token(LBRACE)) return true;
3820 Token xsp;
3821 while (true) {
3822 xsp = jj_scanpos;
3823 if (jj_3_23()) { jj_scanpos = xsp; break; }
3824 }
3825 if (jj_scan_token(RBRACE)) return true;
3826 return false;
3827 }
3828
3829 final private boolean jj_3R_158() {
3830 if (jj_3R_161()) return true;
3831 Token xsp;
3832 while (true) {
3833 xsp = jj_scanpos;
3834 if (jj_3R_167()) { jj_scanpos = xsp; break; }
3835 }
3836 return false;
3837 }
3838
3839 final private boolean jj_3R_40() {
3840 if (jj_scan_token(IDENTIFIER)) return true;
3841 if (jj_scan_token(COLON)) return true;
3842 if (jj_3R_45()) return true;
3843 return false;
3844 }
3845
3846 final private boolean jj_3R_156() {
3847 if (jj_scan_token(HOOK)) return true;
3848 if (jj_3R_39()) return true;
3849 if (jj_scan_token(COLON)) return true;
3850 if (jj_3R_108()) return true;
3851 return false;
3852 }
3853
3854 final private boolean jj_3R_165() {
3855 Token xsp;
3856 xsp = jj_scanpos;
3857 if (jj_scan_token(108)) {
3858 jj_scanpos = xsp;
3859 if (jj_scan_token(109)) return true;
3860 }
3861 if (jj_3R_158()) return true;
3862 return false;
3863 }
3864
3865 final private boolean jj_3R_153() {
3866 if (jj_3R_158()) return true;
3867 Token xsp;
3868 while (true) {
3869 xsp = jj_scanpos;
3870 if (jj_3R_165()) { jj_scanpos = xsp; break; }
3871 }
3872 return false;
3873 }
3874
3875 final private boolean jj_3R_90() {
3876 if (jj_3R_124()) return true;
3877 return false;
3878 }
3879
3880 final private boolean jj_3R_89() {
3881 if (jj_3R_123()) return true;
3882 return false;
3883 }
3884
3885 final private boolean jj_3R_88() {
3886 if (jj_3R_122()) return true;
3887 return false;
3888 }
3889
3890 final private boolean jj_3R_162() {
3891 Token xsp;
3892 xsp = jj_scanpos;
3893 if (jj_scan_token(98)) {
3894 jj_scanpos = xsp;
3895 if (jj_scan_token(99)) return true;
3896 }
3897 if (jj_3R_153()) return true;
3898 return false;
3899 }
3900
3901 final private boolean jj_3R_87() {
3902 if (jj_3R_121()) return true;
3903 return false;
3904 }
3905
3906 final private boolean jj_3R_148() {
3907 if (jj_3R_153()) return true;
3908 Token xsp;
3909 while (true) {
3910 xsp = jj_scanpos;
3911 if (jj_3R_162()) { jj_scanpos = xsp; break; }
3912 }
3913 return false;
3914 }
3915
3916 final private boolean jj_3R_86() {
3917 if (jj_3R_120()) return true;
3918 return false;
3919 }
3920
3921 final private boolean jj_3R_85() {
3922 if (jj_3R_119()) return true;
3923 return false;
3924 }
3925
3926 final private boolean jj_3R_84() {
3927 if (jj_3R_118()) return true;
3928 return false;
3929 }
3930
3931 final private boolean jj_3R_159() {
3932 Token xsp;
3933 xsp = jj_scanpos;
3934 if (jj_scan_token(96)) {
3935 jj_scanpos = xsp;
3936 if (jj_scan_token(97)) return true;
3937 }
3938 if (jj_3R_148()) return true;
3939 return false;
3940 }
3941
3942 final private boolean jj_3R_83() {
3943 if (jj_3R_117()) return true;
3944 return false;
3945 }
3946
3947 final private boolean jj_3R_135() {
3948 if (jj_3R_148()) return true;
3949 Token xsp;
3950 while (true) {
3951 xsp = jj_scanpos;
3952 if (jj_3R_159()) { jj_scanpos = xsp; break; }
3953 }
3954 return false;
3955 }
3956
3957 final private boolean jj_3R_82() {
3958 if (jj_3R_116()) return true;
3959 return false;
3960 }
3961
3962 final private boolean jj_3R_81() {
3963 if (jj_3R_115()) return true;
3964 return false;
3965 }
3966
3967 final private boolean jj_3R_80() {
3968 if (jj_3R_114()) return true;
3969 return false;
3970 }
3971
3972 final private boolean jj_3R_108() {
3973 if (jj_3R_135()) return true;
3974 Token xsp;
3975 xsp = jj_scanpos;
3976 if (jj_3R_156()) jj_scanpos = xsp;
3977 return false;
3978 }
3979
3980 final private boolean jj_3R_79() {
3981 if (jj_3R_113()) return true;
3982 return false;
3983 }
3984
3985 final private boolean jj_3R_78() {
3986 if (jj_3R_112()) return true;
3987 if (jj_scan_token(SEMICOLON)) return true;
3988 return false;
3989 }
3990
3991 final private boolean jj_3_17() {
3992 if (jj_3R_38()) return true;
3993 return false;
3994 }
3995
3996 final private boolean jj_3R_77() {
3997 if (jj_3R_38()) return true;
3998 return false;
3999 }
4000
4001 final private boolean jj_3R_45() {
4002 Token xsp;
4003 xsp = jj_scanpos;
4004 if (jj_3_22()) {
4005 jj_scanpos = xsp;
4006 if (jj_3R_77()) {
4007 jj_scanpos = xsp;
4008 if (jj_scan_token(78)) {
4009 jj_scanpos = xsp;
4010 if (jj_3R_78()) {
4011 jj_scanpos = xsp;
4012 if (jj_3R_79()) {
4013 jj_scanpos = xsp;
4014 if (jj_3R_80()) {
4015 jj_scanpos = xsp;
4016 if (jj_3R_81()) {
4017 jj_scanpos = xsp;
4018 if (jj_3R_82()) {
4019 jj_scanpos = xsp;
4020 lookingAhead = true;
4021 jj_semLA = isRegularForStatement();
4022 lookingAhead = false;
4023 if (!jj_semLA || jj_3R_83()) {
4024 jj_scanpos = xsp;
4025 if (jj_3R_84()) {
4026 jj_scanpos = xsp;
4027 if (jj_3R_85()) {
4028 jj_scanpos = xsp;
4029 if (jj_3R_86()) {
4030 jj_scanpos = xsp;
4031 if (jj_3R_87()) {
4032 jj_scanpos = xsp;
4033 if (jj_3R_88()) {
4034 jj_scanpos = xsp;
4035 if (jj_3R_89()) {
4036 jj_scanpos = xsp;
4037 if (jj_3R_90()) return true;
4038 }
4039 }
4040 }
4041 }
4042 }
4043 }
4044 }
4045 }
4046 }
4047 }
4048 }
4049 }
4050 }
4051 }
4052 }
4053 return false;
4054 }
4055
4056 final private boolean jj_3_22() {
4057 if (jj_3R_40()) return true;
4058 return false;
4059 }
4060
4061 final private boolean jj_3R_34() {
4062 Token xsp;
4063 xsp = jj_scanpos;
4064 if (jj_scan_token(81)) {
4065 jj_scanpos = xsp;
4066 if (jj_scan_token(120)) {
4067 jj_scanpos = xsp;
4068 if (jj_scan_token(121)) {
4069 jj_scanpos = xsp;
4070 if (jj_scan_token(127)) {
4071 jj_scanpos = xsp;
4072 if (jj_scan_token(118)) {
4073 jj_scanpos = xsp;
4074 if (jj_scan_token(119)) {
4075 jj_scanpos = xsp;
4076 if (jj_scan_token(122)) {
4077 jj_scanpos = xsp;
4078 if (jj_scan_token(126)) {
4079 jj_scanpos = xsp;
4080 if (jj_scan_token(124)) {
4081 jj_scanpos = xsp;
4082 if (jj_scan_token(128)) {
4083 jj_scanpos = xsp;
4084 if (jj_scan_token(129)) {
4085 jj_scanpos = xsp;
4086 if (jj_scan_token(130)) {
4087 jj_scanpos = xsp;
4088 if (jj_scan_token(131)) {
4089 jj_scanpos = xsp;
4090 if (jj_scan_token(132)) {
4091 jj_scanpos = xsp;
4092 if (jj_scan_token(133)) return true;
4093 }
4094 }
4095 }
4096 }
4097 }
4098 }
4099 }
4100 }
4101 }
4102 }
4103 }
4104 }
4105 }
4106 }
4107 return false;
4108 }
4109
4110 final private boolean jj_3R_111() {
4111 if (jj_scan_token(COMMA)) return true;
4112 if (jj_3R_29()) return true;
4113 return false;
4114 }
4115
4116 final private boolean jj_3R_160() {
4117 if (jj_scan_token(LBRACKET)) return true;
4118 if (jj_scan_token(RBRACKET)) return true;
4119 return false;
4120 }
4121
4122 final private boolean jj_3R_152() {
4123 if (jj_3R_69()) return true;
4124 Token xsp;
4125 xsp = jj_scanpos;
4126 if (jj_3_17()) jj_scanpos = xsp;
4127 return false;
4128 }
4129
4130 final private boolean jj_3R_157() {
4131 Token xsp;
4132 if (jj_3R_160()) return true;
4133 while (true) {
4134 xsp = jj_scanpos;
4135 if (jj_3R_160()) { jj_scanpos = xsp; break; }
4136 }
4137 if (jj_3R_97()) return true;
4138 return false;
4139 }
4140
4141 final private boolean jj_3_8() {
4142 if (jj_3R_33()) return true;
4143 if (jj_3R_34()) return true;
4144 return false;
4145 }
4146
4147 final private boolean jj_3_20() {
4148 if (jj_scan_token(LBRACKET)) return true;
4149 if (jj_scan_token(RBRACKET)) return true;
4150 return false;
4151 }
4152
4153 final private boolean jj_3R_151() {
4154 if (jj_3R_150()) return true;
4155 return false;
4156 }
4157
4158 final private boolean jj_3_19() {
4159 if (jj_scan_token(LBRACKET)) return true;
4160 if (jj_3R_39()) return true;
4161 if (jj_scan_token(RBRACKET)) return true;
4162 return false;
4163 }
4164
4165 final private boolean jj_3R_107() {
4166 if (jj_3R_33()) return true;
4167 if (jj_3R_34()) return true;
4168 if (jj_3R_39()) return true;
4169 return false;
4170 }
4171
4172 final private boolean jj_3_21() {
4173 Token xsp;
4174 if (jj_3_19()) return true;
4175 while (true) {
4176 xsp = jj_scanpos;
4177 if (jj_3_19()) { jj_scanpos = xsp; break; }
4178 }
4179 while (true) {
4180 xsp = jj_scanpos;
4181 if (jj_3_20()) { jj_scanpos = xsp; break; }
4182 }
4183 return false;
4184 }
4185
4186 final private boolean jj_3R_150() {
4187 Token xsp;
4188 xsp = jj_scanpos;
4189 if (jj_3_21()) {
4190 jj_scanpos = xsp;
4191 if (jj_3R_157()) return true;
4192 }
4193 return false;
4194 }
4195
4196 final private boolean jj_3R_71() {
4197 if (jj_3R_108()) return true;
4198 return false;
4199 }
4200
4201 final private boolean jj_3R_39() {
4202 Token xsp;
4203 xsp = jj_scanpos;
4204 if (jj_3R_70()) {
4205 jj_scanpos = xsp;
4206 if (jj_3R_71()) return true;
4207 }
4208 return false;
4209 }
4210
4211 final private boolean jj_3R_70() {
4212 if (jj_3R_107()) return true;
4213 return false;
4214 }
4215
4216 final private boolean jj_3R_145() {
4217 if (jj_scan_token(NEW)) return true;
4218 if (jj_3R_29()) return true;
4219 Token xsp;
4220 xsp = jj_scanpos;
4221 if (jj_3R_151()) {
4222 jj_scanpos = xsp;
4223 if (jj_3R_152()) return true;
4224 }
4225 return false;
4226 }
4227
4228 final private boolean jj_3_18() {
4229 if (jj_scan_token(NEW)) return true;
4230 if (jj_3R_36()) return true;
4231 if (jj_3R_150()) return true;
4232 return false;
4233 }
4234
4235 final private boolean jj_3R_130() {
4236 Token xsp;
4237 xsp = jj_scanpos;
4238 if (jj_3_18()) {
4239 jj_scanpos = xsp;
4240 if (jj_3R_145()) return true;
4241 }
4242 return false;
4243 }
4244
4245 final private boolean jj_3R_147() {
4246 if (jj_scan_token(COMMA)) return true;
4247 if (jj_3R_39()) return true;
4248 return false;
4249 }
4250
4251 final private boolean jj_3R_76() {
4252 if (jj_3R_29()) return true;
4253 Token xsp;
4254 while (true) {
4255 xsp = jj_scanpos;
4256 if (jj_3R_111()) { jj_scanpos = xsp; break; }
4257 }
4258 return false;
4259 }
4260
4261 final private boolean jj_3R_134() {
4262 if (jj_3R_39()) return true;
4263 Token xsp;
4264 while (true) {
4265 xsp = jj_scanpos;
4266 if (jj_3R_147()) { jj_scanpos = xsp; break; }
4267 }
4268 return false;
4269 }
4270
4271 final private boolean jj_3R_106() {
4272 if (jj_3R_134()) return true;
4273 return false;
4274 }
4275
4276 final private boolean jj_3_7() {
4277 if (jj_scan_token(DOT)) return true;
4278 if (jj_scan_token(IDENTIFIER)) return true;
4279 return false;
4280 }
4281
4282 final private boolean jj_3R_69() {
4283 if (jj_scan_token(LPAREN)) return true;
4284 Token xsp;
4285 xsp = jj_scanpos;
4286 if (jj_3R_106()) jj_scanpos = xsp;
4287 if (jj_scan_token(RPAREN)) return true;
4288 return false;
4289 }
4290
4291 final private boolean jj_3R_29() {
4292 if (jj_scan_token(IDENTIFIER)) return true;
4293 Token xsp;
4294 while (true) {
4295 xsp = jj_scanpos;
4296 if (jj_3_7()) { jj_scanpos = xsp; break; }
4297 }
4298 return false;
4299 }
4300
4301 final private boolean jj_3R_68() {
4302 if (jj_scan_token(DOUBLE)) return true;
4303 return false;
4304 }
4305
4306 final private boolean jj_3R_67() {
4307 if (jj_scan_token(FLOAT)) return true;
4308 return false;
4309 }
4310
4311 final private boolean jj_3R_155() {
4312 if (jj_scan_token(FALSE)) return true;
4313 return false;
4314 }
4315
4316 final private boolean jj_3R_66() {
4317 if (jj_scan_token(LONG)) return true;
4318 return false;
4319 }
4320
4321 final private boolean jj_3R_65() {
4322 if (jj_scan_token(INT)) return true;
4323 return false;
4324 }
4325
4326 final private boolean jj_3R_154() {
4327 if (jj_scan_token(TRUE)) return true;
4328 return false;
4329 }
4330
4331 final private boolean jj_3R_149() {
4332 Token xsp;
4333 xsp = jj_scanpos;
4334 if (jj_3R_154()) {
4335 jj_scanpos = xsp;
4336 if (jj_3R_155()) return true;
4337 }
4338 return false;
4339 }
4340
4341 final private boolean jj_3R_64() {
4342 if (jj_scan_token(SHORT)) return true;
4343 return false;
4344 }
4345
4346 final private boolean jj_3R_56() {
4347 if (jj_3R_29()) return true;
4348 return false;
4349 }
4350
4351 final private boolean jj_3R_63() {
4352 if (jj_scan_token(BYTE)) return true;
4353 return false;
4354 }
4355
4356 final private boolean jj_3R_62() {
4357 if (jj_scan_token(CHAR)) return true;
4358 return false;
4359 }
4360
4361 final private boolean jj_3R_61() {
4362 if (jj_scan_token(BOOLEAN)) return true;
4363 return false;
4364 }
4365
4366 final private boolean jj_3R_36() {
4367 Token xsp;
4368 xsp = jj_scanpos;
4369 if (jj_3R_61()) {
4370 jj_scanpos = xsp;
4371 if (jj_3R_62()) {
4372 jj_scanpos = xsp;
4373 if (jj_3R_63()) {
4374 jj_scanpos = xsp;
4375 if (jj_3R_64()) {
4376 jj_scanpos = xsp;
4377 if (jj_3R_65()) {
4378 jj_scanpos = xsp;
4379 if (jj_3R_66()) {
4380 jj_scanpos = xsp;
4381 if (jj_3R_67()) {
4382 jj_scanpos = xsp;
4383 if (jj_3R_68()) return true;
4384 }
4385 }
4386 }
4387 }
4388 }
4389 }
4390 }
4391 return false;
4392 }
4393
4394 final private boolean jj_3R_144() {
4395 if (jj_scan_token(57)) return true;
4396 return false;
4397 }
4398
4399 final private boolean jj_3R_74() {
4400 if (jj_3R_32()) return true;
4401 return false;
4402 }
4403
4404 final private boolean jj_3R_42() {
4405 Token xsp;
4406 xsp = jj_scanpos;
4407 if (jj_3R_73()) {
4408 jj_scanpos = xsp;
4409 if (jj_3R_74()) return true;
4410 }
4411 return false;
4412 }
4413
4414 final private boolean jj_3R_73() {
4415 if (jj_scan_token(VOID)) return true;
4416 return false;
4417 }
4418
4419 final private boolean jj_3R_143() {
4420 if (jj_scan_token(41)) return true;
4421 return false;
4422 }
4423
4424 final private boolean jj_3_6() {
4425 if (jj_scan_token(LBRACKET)) return true;
4426 if (jj_scan_token(RBRACKET)) return true;
4427 return false;
4428 }
4429
4430 final private boolean jj_3R_142() {
4431 if (jj_3R_149()) return true;
4432 return false;
4433 }
4434
4435 final private boolean jj_3R_55() {
4436 if (jj_3R_36()) return true;
4437 return false;
4438 }
4439
4440 final private boolean jj_3R_110() {
4441 if (jj_scan_token(COMMA)) return true;
4442 if (jj_3R_109()) return true;
4443 return false;
4444 }
4445
4446 final private boolean jj_3R_141() {
4447 if (jj_scan_token(STRING_LITERAL)) return true;
4448 return false;
4449 }
4450
4451 final private boolean jj_3R_32() {
4452 Token xsp;
4453 xsp = jj_scanpos;
4454 if (jj_3R_55()) {
4455 jj_scanpos = xsp;
4456 if (jj_3R_56()) return true;
4457 }
4458 while (true) {
4459 xsp = jj_scanpos;
4460 if (jj_3_6()) { jj_scanpos = xsp; break; }
4461 }
4462 return false;
4463 }
4464
4465 final private boolean jj_3R_140() {
4466 if (jj_scan_token(CHARACTER_LITERAL)) return true;
4467 return false;
4468 }
4469
4470 final private boolean jj_3R_190() {
4471 if (jj_scan_token(FINALLY)) return true;
4472 if (jj_3R_38()) return true;
4473 return false;
4474 }
4475
4476 final private boolean jj_3_4() {
4477 if (jj_scan_token(COMMA)) return true;
4478 if (jj_3R_31()) return true;
4479 return false;
4480 }
4481
4482 final private boolean jj_3R_189() {
4483 if (jj_scan_token(CATCH)) return true;
4484 if (jj_scan_token(LPAREN)) return true;
4485 if (jj_3R_109()) return true;
4486 if (jj_scan_token(RPAREN)) return true;
4487 if (jj_3R_38()) return true;
4488 return false;
4489 }
4490
4491 final private boolean jj_3R_136() {
4492 if (jj_scan_token(IDENTIFIER)) return true;
4493 return false;
4494 }
4495
4496 final private boolean jj_3_5() {
4497 if (jj_3R_32()) return true;
4498 if (jj_scan_token(IDENTIFIER)) return true;
4499 return false;
4500 }
4501
4502 final private boolean jj_3R_75() {
4503 if (jj_3R_109()) return true;
4504 Token xsp;
4505 while (true) {
4506 xsp = jj_scanpos;
4507 if (jj_3R_110()) { jj_scanpos = xsp; break; }
4508 }
4509 return false;
4510 }
4511
4512 final private boolean jj_3R_109() {
4513 Token xsp;
4514 xsp = jj_scanpos;
4515 if (jj_3_5()) {
4516 jj_scanpos = xsp;
4517 if (jj_3R_136()) return true;
4518 }
4519 return false;
4520 }
4521
4522 final private boolean jj_3R_124() {
4523 if (jj_scan_token(TRY)) return true;
4524 if (jj_3R_38()) return true;
4525 Token xsp;
4526 while (true) {
4527 xsp = jj_scanpos;
4528 if (jj_3R_189()) { jj_scanpos = xsp; break; }
4529 }
4530 xsp = jj_scanpos;
4531 if (jj_3R_190()) jj_scanpos = xsp;
4532 return false;
4533 }
4534
4535 final private boolean jj_3R_43() {
4536 if (jj_scan_token(LPAREN)) return true;
4537 Token xsp;
4538 xsp = jj_scanpos;
4539 if (jj_3R_75()) jj_scanpos = xsp;
4540 if (jj_scan_token(RPAREN)) return true;
4541 return false;
4542 }
4543
4544 final private boolean jj_3R_163() {
4545 if (jj_3R_31()) return true;
4546 Token xsp;
4547 while (true) {
4548 xsp = jj_scanpos;
4549 if (jj_3_4()) { jj_scanpos = xsp; break; }
4550 }
4551 return false;
4552 }
4553
4554 final private boolean jj_3R_139() {
4555 if (jj_scan_token(FLOATING_POINT_LITERAL)) return true;
4556 return false;
4557 }
4558
4559 final private boolean jj_3R_97() {
4560 if (jj_scan_token(LBRACE)) return true;
4561 Token xsp;
4562 xsp = jj_scanpos;
4563 if (jj_3R_163()) jj_scanpos = xsp;
4564 xsp = jj_scanpos;
4565 if (jj_scan_token(79)) jj_scanpos = xsp;
4566 if (jj_scan_token(RBRACE)) return true;
4567 return false;
4568 }
4569
4570 final private boolean jj_3R_30() {
4571 if (jj_scan_token(DOT)) return true;
4572 if (jj_scan_token(STAR)) return true;
4573 return false;
4574 }
4575
4576 final private boolean jj_3R_123() {
4577 if (jj_scan_token(THROW)) return true;
4578 if (jj_3R_39()) return true;
4579 if (jj_scan_token(SEMICOLON)) return true;
4580 return false;
4581 }
4582
4583 final private boolean jj_3R_180() {
4584 if (jj_scan_token(ASSIGN)) return true;
4585 if (jj_3R_31()) return true;
4586 return false;
4587 }
4588
4589 final private boolean jj_3R_54() {
4590 if (jj_3R_39()) return true;
4591 return false;
4592 }
4593
4594 final private boolean jj_3R_188() {
4595 if (jj_3R_39()) return true;
4596 return false;
4597 }
4598
4599 final private boolean jj_3R_53() {
4600 if (jj_3R_97()) return true;
4601 return false;
4602 }
4603
4604 final private boolean jj_3R_31() {
4605 Token xsp;
4606 xsp = jj_scanpos;
4607 if (jj_3R_53()) {
4608 jj_scanpos = xsp;
4609 if (jj_3R_54()) return true;
4610 }
4611 return false;
4612 }
4613
4614 final private boolean jj_3R_122() {
4615 if (jj_scan_token(SYNCHRONIZED)) return true;
4616 if (jj_scan_token(LPAREN)) return true;
4617 if (jj_3R_39()) return true;
4618 if (jj_scan_token(RPAREN)) return true;
4619 if (jj_3R_38()) return true;
4620 return false;
4621 }
4622
4623 final private boolean jj_3R_177() {
4624 if (jj_scan_token(COMMA)) return true;
4625 if (jj_3R_176()) return true;
4626 return false;
4627 }
4628
4629 final private boolean jj_3R_210() {
4630 if (jj_scan_token(COMMA)) return true;
4631 if (jj_3R_112()) return true;
4632 return false;
4633 }
4634
4635 final private boolean jj_3R_121() {
4636 if (jj_scan_token(RETURN)) return true;
4637 Token xsp;
4638 xsp = jj_scanpos;
4639 if (jj_3R_188()) jj_scanpos = xsp;
4640 if (jj_scan_token(SEMICOLON)) return true;
4641 return false;
4642 }
4643
4644 final private boolean jj_3R_129() {
4645 Token xsp;
4646 xsp = jj_scanpos;
4647 if (jj_3R_138()) {
4648 jj_scanpos = xsp;
4649 if (jj_3R_139()) {
4650 jj_scanpos = xsp;
4651 if (jj_3R_140()) {
4652 jj_scanpos = xsp;
4653 if (jj_3R_141()) {
4654 jj_scanpos = xsp;
4655 if (jj_3R_142()) {
4656 jj_scanpos = xsp;
4657 if (jj_3R_143()) {
4658 jj_scanpos = xsp;
4659 if (jj_3R_144()) return true;
4660 }
4661 }
4662 }
4663 }
4664 }
4665 }
4666 return false;
4667 }
4668
4669 final private boolean jj_3R_138() {
4670 if (jj_scan_token(INTEGER_LITERAL)) return true;
4671 return false;
4672 }
4673
4674 final private boolean jj_3R_146() {
4675 if (jj_3R_69()) return true;
4676 return false;
4677 }
4678
4679 final private boolean jj_3R_176() {
4680 if (jj_scan_token(IDENTIFIER)) return true;
4681 Token xsp;
4682 xsp = jj_scanpos;
4683 if (jj_3R_180()) jj_scanpos = xsp;
4684 return false;
4685 }
4686
4687 final private boolean jj_3R_105() {
4688 if (jj_3R_129()) return true;
4689 return false;
4690 }
4691
4692 final private boolean jj_3R_120() {
4693 if (jj_scan_token(CONTINUE)) return true;
4694 Token xsp;
4695 xsp = jj_scanpos;
4696 if (jj_scan_token(69)) jj_scanpos = xsp;
4697 if (jj_scan_token(SEMICOLON)) return true;
4698 return false;
4699 }
4700
4701 final private boolean jj_3R_119() {
4702 if (jj_scan_token(BREAK)) return true;
4703 Token xsp;
4704 xsp = jj_scanpos;
4705 if (jj_scan_token(69)) jj_scanpos = xsp;
4706 if (jj_scan_token(SEMICOLON)) return true;
4707 return false;
4708 }
4709
4710 final private boolean jj_3R_195() {
4711 if (jj_3R_205()) return true;
4712 return false;
4713 }
4714
4715 final private boolean jj_3R_128() {
4716 if (jj_scan_token(IMPORT)) return true;
4717 if (jj_scan_token(STAR)) return true;
4718 if (jj_scan_token(SEMICOLON)) return true;
4719 return false;
4720 }
4721
4722 final private boolean jj_3R_133() {
4723 if (jj_scan_token(LBRACE)) return true;
4724 if (jj_3R_39()) return true;
4725 if (jj_scan_token(RBRACE)) return true;
4726 return false;
4727 }
4728
4729 final private boolean jj_3R_205() {
4730 if (jj_3R_112()) return true;
4731 Token xsp;
4732 while (true) {
4733 xsp = jj_scanpos;
4734 if (jj_3R_210()) { jj_scanpos = xsp; break; }
4735 }
4736 return false;
4737 }
4738
4739 final private boolean jj_3R_132() {
4740 if (jj_scan_token(DOT)) return true;
4741 if (jj_scan_token(IDENTIFIER)) return true;
4742 Token xsp;
4743 xsp = jj_scanpos;
4744 if (jj_3R_146()) jj_scanpos = xsp;
4745 return false;
4746 }
4747
4748 final private boolean jj_3_3() {
4749 Token xsp;
4750 xsp = jj_scanpos;
4751 if (jj_scan_token(48)) jj_scanpos = xsp;
4752 if (jj_scan_token(IMPORT)) return true;
4753 if (jj_3R_29()) return true;
4754 xsp = jj_scanpos;
4755 if (jj_3R_30()) jj_scanpos = xsp;
4756 if (jj_scan_token(SEMICOLON)) return true;
4757 return false;
4758 }
4759
4760 final private boolean jj_3R_94() {
4761 Token xsp;
4762 xsp = jj_scanpos;
4763 if (jj_3_3()) {
4764 jj_scanpos = xsp;
4765 if (jj_3R_128()) return true;
4766 }
4767 return false;
4768 }
4769
4770 final private boolean jj_3R_93() {
4771 if (jj_3R_41()) return true;
4772 if (jj_3R_32()) return true;
4773 if (jj_3R_176()) return true;
4774 Token xsp;
4775 while (true) {
4776 xsp = jj_scanpos;
4777 if (jj_3R_177()) { jj_scanpos = xsp; break; }
4778 }
4779 return false;
4780 }
4781
4782 final private boolean jj_3R_131() {
4783 if (jj_scan_token(LBRACKET)) return true;
4784 if (jj_3R_39()) return true;
4785 if (jj_scan_token(RBRACKET)) return true;
4786 return false;
4787 }
4788
4789 final private boolean jj_3R_95() {
4790 if (jj_scan_token(PACKAGE)) return true;
4791 if (jj_3R_29()) return true;
4792 return false;
4793 }
4794
4795 final private boolean jj_3_2() {
4796 if (jj_scan_token(IDENTIFIER)) return true;
4797 if (jj_scan_token(LPAREN)) return true;
4798 return false;
4799 }
4800
4801 final private boolean jj_3R_175() {
4802 if (jj_3R_38()) return true;
4803 return false;
4804 }
4805
4806 final private boolean jj_3_16() {
4807 if (jj_scan_token(DOT)) return true;
4808 if (jj_scan_token(CLASS)) return true;
4809 return false;
4810 }
4811
4812 final private boolean jj_3R_104() {
4813 Token xsp;
4814 xsp = jj_scanpos;
4815 if (jj_3_16()) {
4816 jj_scanpos = xsp;
4817 if (jj_3R_131()) {
4818 jj_scanpos = xsp;
4819 if (jj_3R_132()) {
4820 jj_scanpos = xsp;
4821 if (jj_3R_133()) return true;
4822 }
4823 }
4824 }
4825 return false;
4826 }
4827
4828 final private boolean jj_3R_174() {
4829 if (jj_scan_token(THROWS)) return true;
4830 if (jj_3R_76()) return true;
4831 return false;
4832 }
4833
4834 final private boolean jj_3_15() {
4835 if (jj_3R_32()) return true;
4836 if (jj_scan_token(DOT)) return true;
4837 if (jj_scan_token(CLASS)) return true;
4838 return false;
4839 }
4840
4841 final private boolean jj_3_31() {
4842 if (jj_3R_41()) return true;
4843 if (jj_3R_32()) return true;
4844 if (jj_scan_token(IDENTIFIER)) return true;
4845 return false;
4846 }
4847
4848 final private boolean jj_3_14() {
4849 if (jj_3R_37()) return true;
4850 return false;
4851 }
4852
4853 final private boolean jj_3R_126() {
4854 if (jj_scan_token(IDENTIFIER)) return true;
4855 return false;
4856 }
4857
4858 final private boolean jj_3R_127() {
4859 if (jj_3R_42()) return true;
4860 if (jj_scan_token(IDENTIFIER)) return true;
4861 return false;
4862 }
4863
4864 final private boolean jj_3R_92() {
4865 if (jj_3R_41()) return true;
4866 Token xsp;
4867 xsp = jj_scanpos;
4868 if (jj_3R_126()) {
4869 jj_scanpos = xsp;
4870 if (jj_3R_127()) return true;
4871 }
4872 if (jj_3R_43()) return true;
4873 xsp = jj_scanpos;
4874 if (jj_3R_174()) jj_scanpos = xsp;
4875 xsp = jj_scanpos;
4876 if (jj_3R_175()) {
4877 jj_scanpos = xsp;
4878 if (jj_scan_token(78)) return true;
4879 }
4880 return false;
4881 }
4882
4883 final private boolean jj_3R_204() {
4884 if (jj_3R_205()) return true;
4885 return false;
4886 }
4887
4888 final private boolean jj_3R_103() {
4889 if (jj_3R_29()) return true;
4890 return false;
4891 }
4892
4893 final private boolean jj_3R_203() {
4894 if (jj_3R_93()) return true;
4895 return false;
4896 }
4897
4898 final private boolean jj_3R_194() {
4899 Token xsp;
4900 xsp = jj_scanpos;
4901 if (jj_3R_203()) {
4902 jj_scanpos = xsp;
4903 if (jj_3R_204()) return true;
4904 }
4905 return false;
4906 }
4907
4908 final private boolean jj_3R_102() {
4909 if (jj_3R_32()) return true;
4910 return false;
4911 }
4912
4913 final private boolean jj_3R_58() {
4914 if (jj_3R_104()) return true;
4915 return false;
4916 }
4917
4918 final private boolean jj_3R_125() {
4919 if (jj_scan_token(INTERFACE)) return true;
4920 return false;
4921 }
4922
4923 final private boolean jj_3R_101() {
4924 if (jj_3R_37()) return true;
4925 return false;
4926 }
4927
4928 final private boolean jj_3R_100() {
4929 if (jj_3R_130()) return true;
4930 return false;
4931 }
4932
4933 final private boolean jj_3R_99() {
4934 if (jj_scan_token(LPAREN)) return true;
4935 if (jj_3R_39()) return true;
4936 if (jj_scan_token(RPAREN)) return true;
4937 return false;
4938 }
4939
4940 final private boolean jj_3R_137() {
4941 if (jj_scan_token(FOR)) return true;
4942 if (jj_scan_token(LPAREN)) return true;
4943 if (jj_3R_32()) return true;
4944 if (jj_scan_token(IDENTIFIER)) return true;
4945 if (jj_scan_token(COLON)) return true;
4946 if (jj_3R_39()) return true;
4947 if (jj_scan_token(RPAREN)) return true;
4948 if (jj_3R_45()) return true;
4949 return false;
4950 }
4951
4952 final private boolean jj_3R_184() {
4953 if (jj_scan_token(ELSE)) return true;
4954 if (jj_3R_45()) return true;
4955 return false;
4956 }
4957
4958 final private boolean jj_3R_173() {
4959 if (jj_scan_token(IMPLEMENTS)) return true;
4960 if (jj_3R_76()) return true;
4961 return false;
4962 }
4963
4964 final private boolean jj_3R_57() {
4965 Token xsp;
4966 xsp = jj_scanpos;
4967 if (jj_3R_98()) {
4968 jj_scanpos = xsp;
4969 if (jj_3R_99()) {
4970 jj_scanpos = xsp;
4971 if (jj_3R_100()) {
4972 jj_scanpos = xsp;
4973 if (jj_3R_101()) {
4974 jj_scanpos = xsp;
4975 if (jj_3R_102()) {
4976 jj_scanpos = xsp;
4977 if (jj_3R_103()) return true;
4978 }
4979 }
4980 }
4981 }
4982 }
4983 return false;
4984 }
4985
4986 final private boolean jj_3R_98() {
4987 if (jj_3R_129()) return true;
4988 return false;
4989 }
4990
4991 final private boolean jj_3R_172() {
4992 if (jj_scan_token(EXTENDS)) return true;
4993 if (jj_3R_29()) return true;
4994 return false;
4995 }
4996
4997 final private boolean jj_3_30() {
4998 if (jj_scan_token(FOR)) return true;
4999 if (jj_scan_token(LPAREN)) return true;
5000 if (jj_scan_token(IDENTIFIER)) return true;
5001 if (jj_scan_token(COLON)) return true;
5002 if (jj_3R_39()) return true;
5003 if (jj_scan_token(RPAREN)) return true;
5004 if (jj_3R_45()) return true;
5005 return false;
5006 }
5007
5008 final private boolean jj_3R_118() {
5009 Token xsp;
5010 xsp = jj_scanpos;
5011 if (jj_3_30()) {
5012 jj_scanpos = xsp;
5013 if (jj_3R_137()) return true;
5014 }
5015 return false;
5016 }
5017
5018 final private boolean jj_3R_37() {
5019 if (jj_3R_29()) return true;
5020 if (jj_3R_69()) return true;
5021 return false;
5022 }
5023
5024 final private boolean jj_3R_185() {
5025 if (jj_3R_194()) return true;
5026 return false;
5027 }
5028
5029 final private boolean jj_3R_91() {
5030 if (jj_3R_41()) return true;
5031 Token xsp;
5032 xsp = jj_scanpos;
5033 if (jj_scan_token(13)) {
5034 jj_scanpos = xsp;
5035 if (jj_3R_125()) return true;
5036 }
5037 if (jj_scan_token(IDENTIFIER)) return true;
5038 xsp = jj_scanpos;
5039 if (jj_3R_172()) jj_scanpos = xsp;
5040 xsp = jj_scanpos;
5041 if (jj_3R_173()) jj_scanpos = xsp;
5042 if (jj_3R_38()) return true;
5043 return false;
5044 }
5045
5046 final private boolean jj_3_13() {
5047 if (jj_scan_token(LPAREN)) return true;
5048 if (jj_3R_36()) return true;
5049 return false;
5050 }
5051
5052 final private boolean jj_3R_187() {
5053 if (jj_3R_195()) return true;
5054 return false;
5055 }
5056
5057 final private boolean jj_3R_186() {
5058 if (jj_3R_39()) return true;
5059 return false;
5060 }
5061
5062 final private boolean jj_3R_33() {
5063 if (jj_3R_57()) return true;
5064 Token xsp;
5065 while (true) {
5066 xsp = jj_scanpos;
5067 if (jj_3R_58()) { jj_scanpos = xsp; break; }
5068 }
5069 return false;
5070 }
5071
5072 final private boolean jj_3R_217() {
5073 if (jj_scan_token(LPAREN)) return true;
5074 if (jj_3R_32()) return true;
5075 if (jj_scan_token(RPAREN)) return true;
5076 if (jj_3R_208()) return true;
5077 return false;
5078 }
5079
5080 final private boolean jj_3R_216() {
5081 if (jj_scan_token(LPAREN)) return true;
5082 if (jj_3R_32()) return true;
5083 if (jj_scan_token(RPAREN)) return true;
5084 if (jj_3R_191()) return true;
5085 return false;
5086 }
5087
5088 final private boolean jj_3R_117() {
5089 if (jj_scan_token(FOR)) return true;
5090 if (jj_scan_token(LPAREN)) return true;
5091 Token xsp;
5092 xsp = jj_scanpos;
5093 if (jj_3R_185()) jj_scanpos = xsp;
5094 if (jj_scan_token(SEMICOLON)) return true;
5095 xsp = jj_scanpos;
5096 if (jj_3R_186()) jj_scanpos = xsp;
5097 if (jj_scan_token(SEMICOLON)) return true;
5098 xsp = jj_scanpos;
5099 if (jj_3R_187()) jj_scanpos = xsp;
5100 if (jj_scan_token(RPAREN)) return true;
5101 if (jj_3R_45()) return true;
5102 return false;
5103 }
5104
5105 final private boolean jj_3R_214() {
5106 Token xsp;
5107 xsp = jj_scanpos;
5108 if (jj_3R_216()) {
5109 jj_scanpos = xsp;
5110 if (jj_3R_217()) return true;
5111 }
5112 return false;
5113 }
5114
5115 final private boolean jj_3_12() {
5116 if (jj_3R_33()) return true;
5117 Token xsp;
5118 xsp = jj_scanpos;
5119 if (jj_scan_token(100)) {
5120 jj_scanpos = xsp;
5121 if (jj_scan_token(101)) return true;
5122 }
5123 return false;
5124 }
5125
5126 final private boolean jj_3R_219() {
5127 if (jj_3R_33()) return true;
5128 return false;
5129 }
5130
5131 final private boolean jj_3R_116() {
5132 if (jj_scan_token(DO)) return true;
5133 if (jj_3R_45()) return true;
5134 if (jj_scan_token(WHILE)) return true;
5135 if (jj_scan_token(LPAREN)) return true;
5136 if (jj_3R_39()) return true;
5137 if (jj_scan_token(RPAREN)) return true;
5138 if (jj_scan_token(SEMICOLON)) return true;
5139 return false;
5140 }
5141
5142 final private boolean jj_3_11() {
5143 if (jj_scan_token(LPAREN)) return true;
5144 if (jj_3R_29()) return true;
5145 if (jj_scan_token(LBRACKET)) return true;
5146 return false;
5147 }
5148
5149 final private boolean jj_3R_218() {
5150 if (jj_3R_33()) return true;
5151 Token xsp;
5152 xsp = jj_scanpos;
5153 if (jj_scan_token(100)) {
5154 jj_scanpos = xsp;
5155 if (jj_scan_token(101)) return true;
5156 }
5157 return false;
5158 }
5159
5160 final private boolean jj_3R_215() {
5161 Token xsp;
5162 xsp = jj_scanpos;
5163 if (jj_3R_218()) {
5164 jj_scanpos = xsp;
5165 if (jj_3R_219()) return true;
5166 }
5167 return false;
5168 }
5169
5170 final private boolean jj_3R_72() {
5171 Token xsp;
5172 xsp = jj_scanpos;
5173 if (jj_scan_token(43)) {
5174 jj_scanpos = xsp;
5175 if (jj_scan_token(44)) {
5176 jj_scanpos = xsp;
5177 if (jj_scan_token(45)) {
5178 jj_scanpos = xsp;
5179 if (jj_scan_token(51)) {
5180 jj_scanpos = xsp;
5181 if (jj_scan_token(27)) {
5182 jj_scanpos = xsp;
5183 if (jj_scan_token(39)) {
5184 jj_scanpos = xsp;
5185 if (jj_scan_token(52)) {
5186 jj_scanpos = xsp;
5187 if (jj_scan_token(58)) {
5188 jj_scanpos = xsp;
5189 if (jj_scan_token(10)) {
5190 jj_scanpos = xsp;
5191 if (jj_scan_token(48)) {
5192 jj_scanpos = xsp;
5193 if (jj_scan_token(49)) return true;
5194 }
5195 }
5196 }
5197 }
5198 }
5199 }
5200 }
5201 }
5202 }
5203 }
5204 return false;
5205 }
5206
5207 final private boolean jj_3R_115() {
5208 if (jj_scan_token(WHILE)) return true;
5209 if (jj_scan_token(LPAREN)) return true;
5210 if (jj_3R_39()) return true;
5211 if (jj_scan_token(RPAREN)) return true;
5212 if (jj_3R_45()) return true;
5213 return false;
5214 }
5215
5216 final private boolean jj_3R_60() {
5217 if (jj_scan_token(LPAREN)) return true;
5218 if (jj_3R_29()) return true;
5219 if (jj_scan_token(RPAREN)) return true;
5220 Token xsp;
5221 xsp = jj_scanpos;
5222 if (jj_scan_token(87)) {
5223 jj_scanpos = xsp;
5224 if (jj_scan_token(86)) {
5225 jj_scanpos = xsp;
5226 if (jj_scan_token(72)) {
5227 jj_scanpos = xsp;
5228 if (jj_scan_token(69)) {
5229 jj_scanpos = xsp;
5230 if (jj_scan_token(40)) {
5231 jj_scanpos = xsp;
5232 if (jj_3R_105()) return true;
5233 }
5234 }
5235 }
5236 }
5237 }
5238 return false;
5239 }
5240
5241 final private boolean jj_3R_59() {
5242 if (jj_scan_token(LPAREN)) return true;
5243 if (jj_3R_29()) return true;
5244 if (jj_scan_token(LBRACKET)) return true;
5245 if (jj_scan_token(RBRACKET)) return true;
5246 return false;
5247 }
5248
5249 final private boolean jj_3_9() {
5250 if (jj_3R_35()) return true;
5251 return false;
5252 }
5253
5254 final private boolean jj_3_29() {
5255 if (jj_3R_28()) return true;
5256 return false;
5257 }
5258
5259 final private boolean jj_3R_114() {
5260 if (jj_scan_token(IF)) return true;
5261 if (jj_scan_token(LPAREN)) return true;
5262 if (jj_3R_39()) return true;
5263 if (jj_scan_token(RPAREN)) return true;
5264 if (jj_3R_45()) return true;
5265 Token xsp;
5266 xsp = jj_scanpos;
5267 if (jj_3R_184()) jj_scanpos = xsp;
5268 return false;
5269 }
5270
5271 final private boolean jj_3R_41() {
5272 Token xsp;
5273 while (true) {
5274 xsp = jj_scanpos;
5275 if (jj_3R_72()) { jj_scanpos = xsp; break; }
5276 }
5277 return false;
5278 }
5279
5280 final private boolean jj_3R_35() {
5281 Token xsp;
5282 xsp = jj_scanpos;
5283 if (jj_3_10()) {
5284 jj_scanpos = xsp;
5285 if (jj_3R_59()) {
5286 jj_scanpos = xsp;
5287 if (jj_3R_60()) return true;
5288 }
5289 }
5290 return false;
5291 }
5292
5293 final private boolean jj_3_10() {
5294 if (jj_scan_token(LPAREN)) return true;
5295 if (jj_3R_36()) return true;
5296 return false;
5297 }
5298
5299 final private boolean jj_3R_213() {
5300 if (jj_3R_215()) return true;
5301 return false;
5302 }
5303
5304 final private boolean jj_3R_212() {
5305 if (jj_3R_214()) return true;
5306 return false;
5307 }
5308
5309 final private boolean jj_3R_202() {
5310 if (jj_scan_token(_DEFAULT)) return true;
5311 if (jj_scan_token(COLON)) return true;
5312 return false;
5313 }
5314
5315 final private boolean jj_3R_211() {
5316 Token xsp;
5317 xsp = jj_scanpos;
5318 if (jj_scan_token(87)) {
5319 jj_scanpos = xsp;
5320 if (jj_scan_token(86)) return true;
5321 }
5322 if (jj_3R_191()) return true;
5323 return false;
5324 }
5325
5326 final private boolean jj_3R_208() {
5327 Token xsp;
5328 xsp = jj_scanpos;
5329 if (jj_3R_211()) {
5330 jj_scanpos = xsp;
5331 if (jj_3R_212()) {
5332 jj_scanpos = xsp;
5333 if (jj_3R_213()) return true;
5334 }
5335 }
5336 return false;
5337 }
5338
5339 final private boolean jj_3R_201() {
5340 if (jj_scan_token(CASE)) return true;
5341 if (jj_3R_39()) return true;
5342 if (jj_scan_token(COLON)) return true;
5343 return false;
5344 }
5345
5346 final private boolean jj_3R_193() {
5347 Token xsp;
5348 xsp = jj_scanpos;
5349 if (jj_3R_201()) {
5350 jj_scanpos = xsp;
5351 if (jj_3R_202()) return true;
5352 }
5353 return false;
5354 }
5355
5356 final private boolean jj_3R_183() {
5357 if (jj_3R_193()) return true;
5358 Token xsp;
5359 while (true) {
5360 xsp = jj_scanpos;
5361 if (jj_3_29()) { jj_scanpos = xsp; break; }
5362 }
5363 return false;
5364 }
5365
5366 final private boolean jj_3R_207() {
5367 if (jj_scan_token(DECR)) return true;
5368 if (jj_3R_33()) return true;
5369 return false;
5370 }
5371
5372 final private boolean jj_3_1() {
5373 if (jj_3R_28()) return true;
5374 return false;
5375 }
5376
5377 final private boolean jj_3R_113() {
5378 if (jj_scan_token(SWITCH)) return true;
5379 if (jj_scan_token(LPAREN)) return true;
5380 if (jj_3R_39()) return true;
5381 if (jj_scan_token(RPAREN)) return true;
5382 if (jj_scan_token(LBRACE)) return true;
5383 Token xsp;
5384 while (true) {
5385 xsp = jj_scanpos;
5386 if (jj_3R_183()) { jj_scanpos = xsp; break; }
5387 }
5388 if (jj_scan_token(RBRACE)) return true;
5389 return false;
5390 }
5391
5392 final private boolean jj_3R_209() {
5393 Token xsp;
5394 xsp = jj_scanpos;
5395 if (jj_scan_token(104)) {
5396 jj_scanpos = xsp;
5397 if (jj_scan_token(105)) {
5398 jj_scanpos = xsp;
5399 if (jj_scan_token(111)) return true;
5400 }
5401 }
5402 if (jj_3R_191()) return true;
5403 return false;
5404 }
5405
5406 final private boolean jj_3R_206() {
5407 if (jj_scan_token(INCR)) return true;
5408 if (jj_3R_33()) return true;
5409 return false;
5410 }
5411
5412 final private boolean jj_3R_199() {
5413 if (jj_3R_208()) return true;
5414 return false;
5415 }
5416
5417 final private boolean jj_3R_198() {
5418 if (jj_3R_207()) return true;
5419 return false;
5420 }
5421
5422 final private boolean jj_3R_197() {
5423 if (jj_3R_206()) return true;
5424 return false;
5425 }
5426
5427 final private boolean jj_3R_196() {
5428 Token xsp;
5429 xsp = jj_scanpos;
5430 if (jj_scan_token(102)) {
5431 jj_scanpos = xsp;
5432 if (jj_scan_token(103)) return true;
5433 }
5434 if (jj_3R_191()) return true;
5435 return false;
5436 }
5437
5438 final private boolean jj_3R_191() {
5439 Token xsp;
5440 xsp = jj_scanpos;
5441 if (jj_3R_196()) {
5442 jj_scanpos = xsp;
5443 if (jj_3R_197()) {
5444 jj_scanpos = xsp;
5445 if (jj_3R_198()) {
5446 jj_scanpos = xsp;
5447 if (jj_3R_199()) return true;
5448 }
5449 }
5450 }
5451 return false;
5452 }
5453
5454 final private boolean jj_3R_44() {
5455 if (jj_scan_token(THROWS)) return true;
5456 if (jj_3R_76()) return true;
5457 return false;
5458 }
5459
5460 final private boolean jj_3R_112() {
5461 if (jj_3R_39()) return true;
5462 return false;
5463 }
5464
5465 final private boolean jj_3R_181() {
5466 if (jj_3R_191()) return true;
5467 Token xsp;
5468 while (true) {
5469 xsp = jj_scanpos;
5470 if (jj_3R_209()) { jj_scanpos = xsp; break; }
5471 }
5472 return false;
5473 }
5474
5475 final private boolean jj_3R_200() {
5476 Token xsp;
5477 xsp = jj_scanpos;
5478 if (jj_scan_token(102)) {
5479 jj_scanpos = xsp;
5480 if (jj_scan_token(103)) return true;
5481 }
5482 if (jj_3R_181()) return true;
5483 return false;
5484 }
5485
5486 final private boolean jj_3R_178() {
5487 if (jj_3R_181()) return true;
5488 Token xsp;
5489 while (true) {
5490 xsp = jj_scanpos;
5491 if (jj_3R_200()) { jj_scanpos = xsp; break; }
5492 }
5493 return false;
5494 }
5495
5496 final private boolean jj_3R_96() {
5497 if (jj_scan_token(FORMAL_COMMENT)) return true;
5498 return false;
5499 }
5500
5501 final private boolean jj_3R_192() {
5502 Token xsp;
5503 xsp = jj_scanpos;
5504 if (jj_scan_token(112)) {
5505 jj_scanpos = xsp;
5506 if (jj_scan_token(113)) {
5507 jj_scanpos = xsp;
5508 if (jj_scan_token(114)) {
5509 jj_scanpos = xsp;
5510 if (jj_scan_token(115)) {
5511 jj_scanpos = xsp;
5512 if (jj_scan_token(116)) {
5513 jj_scanpos = xsp;
5514 if (jj_scan_token(117)) return true;
5515 }
5516 }
5517 }
5518 }
5519 }
5520 if (jj_3R_178()) return true;
5521 return false;
5522 }
5523
5524 final private boolean jj_3R_171() {
5525 Token xsp;
5526 xsp = jj_scanpos;
5527 if (jj_scan_token(90)) {
5528 jj_scanpos = xsp;
5529 if (jj_scan_token(95)) return true;
5530 }
5531 if (jj_3R_166()) return true;
5532 return false;
5533 }
5534
5535 final private boolean jj_3R_170() {
5536 if (jj_3R_178()) return true;
5537 Token xsp;
5538 while (true) {
5539 xsp = jj_scanpos;
5540 if (jj_3R_192()) { jj_scanpos = xsp; break; }
5541 }
5542 return false;
5543 }
5544
5545 final private boolean jj_3R_52() {
5546 if (jj_3R_96()) return true;
5547 return false;
5548 }
5549
5550 final private boolean jj_3R_182() {
5551 Token xsp;
5552 xsp = jj_scanpos;
5553 if (jj_scan_token(84)) {
5554 jj_scanpos = xsp;
5555 if (jj_scan_token(85)) {
5556 jj_scanpos = xsp;
5557 if (jj_scan_token(82)) {
5558 jj_scanpos = xsp;
5559 if (jj_scan_token(83)) {
5560 jj_scanpos = xsp;
5561 if (jj_scan_token(91)) {
5562 jj_scanpos = xsp;
5563 if (jj_scan_token(92)) {
5564 jj_scanpos = xsp;
5565 if (jj_scan_token(93)) {
5566 jj_scanpos = xsp;
5567 if (jj_scan_token(94)) return true;
5568 }
5569 }
5570 }
5571 }
5572 }
5573 }
5574 }
5575 if (jj_3R_170()) return true;
5576 return false;
5577 }
5578
5579 final private boolean jj_3_27() {
5580 if (jj_3R_41()) return true;
5581 if (jj_3R_32()) return true;
5582 if (jj_scan_token(IDENTIFIER)) return true;
5583 return false;
5584 }
5585
5586 final private boolean jj_3R_51() {
5587 if (jj_3R_95()) return true;
5588 return false;
5589 }
5590
5591 final private boolean jj_3R_168() {
5592 if (jj_3R_170()) return true;
5593 Token xsp;
5594 while (true) {
5595 xsp = jj_scanpos;
5596 if (jj_3R_182()) { jj_scanpos = xsp; break; }
5597 }
5598 return false;
5599 }
5600
5601 final private boolean jj_3R_50() {
5602 if (jj_3R_94()) return true;
5603 return false;
5604 }
5605
5606 final private boolean jj_3_26() {
5607 if (jj_3R_41()) return true;
5608 if (jj_scan_token(IDENTIFIER)) return true;
5609 if (jj_3R_43()) return true;
5610 Token xsp;
5611 xsp = jj_scanpos;
5612 if (jj_3R_44()) jj_scanpos = xsp;
5613 if (jj_scan_token(LBRACE)) return true;
5614 return false;
5615 }
5616
5617 final private boolean jj_3R_179() {
5618 if (jj_scan_token(INSTANCEOF)) return true;
5619 if (jj_3R_32()) return true;
5620 return false;
5621 }
5622
5623 final private boolean jj_3_28() {
5624 if (jj_3R_45()) return true;
5625 return false;
5626 }
5627
5628 final private boolean jj_3R_166() {
5629 if (jj_3R_168()) return true;
5630 Token xsp;
5631 xsp = jj_scanpos;
5632 if (jj_3R_179()) jj_scanpos = xsp;
5633 return false;
5634 }
5635
5636 final private boolean jj_3_25() {
5637 if (jj_3R_41()) return true;
5638 if (jj_3R_42()) return true;
5639 if (jj_scan_token(IDENTIFIER)) return true;
5640 if (jj_scan_token(LPAREN)) return true;
5641 return false;
5642 }
5643
5644 final private boolean jj_3R_49() {
5645 if (jj_3R_93()) return true;
5646 if (jj_scan_token(SEMICOLON)) return true;
5647 return false;
5648 }
5649
5650 final private boolean jj_3_24() {
5651 if (jj_3R_41()) return true;
5652 Token xsp;
5653 xsp = jj_scanpos;
5654 if (jj_scan_token(13)) {
5655 jj_scanpos = xsp;
5656 if (jj_scan_token(37)) return true;
5657 }
5658 return false;
5659 }
5660
5661 final private boolean jj_3R_167() {
5662 if (jj_scan_token(XOR)) return true;
5663 if (jj_3R_161()) return true;
5664 return false;
5665 }
5666
5667 final private boolean jj_3R_48() {
5668 if (jj_3R_92()) return true;
5669 return false;
5670 }
5671
5672 final private boolean jj_3R_164() {
5673 if (jj_3R_166()) return true;
5674 Token xsp;
5675 while (true) {
5676 xsp = jj_scanpos;
5677 if (jj_3R_171()) { jj_scanpos = xsp; break; }
5678 }
5679 return false;
5680 }
5681
5682 final private boolean jj_3R_47() {
5683 if (jj_3R_92()) return true;
5684 return false;
5685 }
5686
5687 final private boolean jj_3R_169() {
5688 Token xsp;
5689 xsp = jj_scanpos;
5690 if (jj_scan_token(106)) {
5691 jj_scanpos = xsp;
5692 if (jj_scan_token(107)) return true;
5693 }
5694 if (jj_3R_164()) return true;
5695 return false;
5696 }
5697
5698 public ParserTokenManager token_source;
5699 JavaCharStream jj_input_stream;
5700 public Token token, jj_nt;
5701 private int jj_ntk;
5702 private Token jj_scanpos, jj_lastpos;
5703 private int jj_la;
5704 public boolean lookingAhead = false;
5705 private boolean jj_semLA;
5706
5707 public Parser(java.io.InputStream stream) {
5708 jj_input_stream = new JavaCharStream(stream, 1, 1);
5709 token_source = new ParserTokenManager(jj_input_stream);
5710 token = new Token();
5711 jj_ntk = -1;
5712 }
5713
5714 public void ReInit(java.io.InputStream stream) {
5715 jj_input_stream.ReInit(stream, 1, 1);
5716 token_source.ReInit(jj_input_stream);
5717 token = new Token();
5718 jj_ntk = -1;
5719 jjtree.reset();
5720 }
5721
5722 public Parser(java.io.Reader stream) {
5723 jj_input_stream = new JavaCharStream(stream, 1, 1);
5724 token_source = new ParserTokenManager(jj_input_stream);
5725 token = new Token();
5726 jj_ntk = -1;
5727 }
5728
5729 public void ReInit(java.io.Reader stream) {
5730 jj_input_stream.ReInit(stream, 1, 1);
5731 token_source.ReInit(jj_input_stream);
5732 token = new Token();
5733 jj_ntk = -1;
5734 jjtree.reset();
5735 }
5736
5737 public Parser(ParserTokenManager tm) {
5738 token_source = tm;
5739 token = new Token();
5740 jj_ntk = -1;
5741 }
5742
5743 public void ReInit(ParserTokenManager tm) {
5744 token_source = tm;
5745 token = new Token();
5746 jj_ntk = -1;
5747 jjtree.reset();
5748 }
5749
5750 final private Token jj_consume_token(int kind) throws ParseException {
5751 Token oldToken;
5752 if ((oldToken = token).next != null) token = token.next;
5753 else token = token.next = token_source.getNextToken();
5754 jj_ntk = -1;
5755 if (token.kind == kind) {
5756 return token;
5757 }
5758 token = oldToken;
5759 throw generateParseException();
5760 }
5761
5762 static private final class LookaheadSuccess extends java.lang.Error { }
5763 final private LookaheadSuccess jj_ls = new LookaheadSuccess();
5764 final private boolean jj_scan_token(int kind) {
5765 if (jj_scanpos == jj_lastpos) {
5766 jj_la--;
5767 if (jj_scanpos.next == null) {
5768 jj_lastpos = jj_scanpos = jj_scanpos.next = token_source.getNextToken();
5769 } else {
5770 jj_lastpos = jj_scanpos = jj_scanpos.next;
5771 }
5772 } else {
5773 jj_scanpos = jj_scanpos.next;
5774 }
5775 if (jj_scanpos.kind != kind) return true;
5776 if (jj_la == 0 && jj_scanpos == jj_lastpos) throw jj_ls;
5777 return false;
5778 }
5779
5780 final public Token getNextToken() {
5781 if (token.next != null) token = token.next;
5782 else token = token.next = token_source.getNextToken();
5783 jj_ntk = -1;
5784 return token;
5785 }
5786
5787 final public Token getToken(int index) {
5788 Token t = lookingAhead ? jj_scanpos : token;
5789 for (int i = 0; i < index; i++) {
5790 if (t.next != null) t = t.next;
5791 else t = t.next = token_source.getNextToken();
5792 }
5793 return t;
5794 }
5795
5796 final private int jj_ntk() {
5797 if ((jj_nt=token.next) == null)
5798 return (jj_ntk = (token.next=token_source.getNextToken()).kind);
5799 else
5800 return (jj_ntk = jj_nt.kind);
5801 }
5802
5803 public ParseException generateParseException() {
5804 Token errortok = token.next;
5805 int line = errortok.beginLine, column = errortok.beginColumn;
5806 String mess = (errortok.kind == 0) ? tokenImage[0] : errortok.image;
5807 return new ParseException("Parse error at line " + line + ", column " + column + ". Encountered: " + mess);
5808 }
5809
5810 final public void enable_tracing() {
5811 }
5812
5813 final public void disable_tracing() {
5814 }
5815
5816}
5817 |
Popular Tags |
Java API By Example, From Geeks To Geeks.