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