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 SimpleParser implements JavaParser, SimpleParserConstants {
10 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 SimpleParser( 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 switch (jj_nt.kind) {
152 case PACKAGE:
153 PackageDeclaration();
154 break;
155 default:
156 jj_la1[0] = jj_gen;
157 ;
158 }
159 label_1:
160 while (true) {
161 switch (jj_nt.kind) {
162 case IMPORT:
163 ;
164 break;
165 default:
166 jj_la1[1] = jj_gen;
167 break label_1;
168 }
169 ImportDeclaration();
170 }
171 label_2:
172 while (true) {
173 switch (jj_nt.kind) {
174 case ABSTRACT:
175 case CLASS:
176 case FINAL:
177 case INTERFACE:
178 case PUBLIC:
179 case STRICTFP:
180 case SEMICOLON:
181 ;
182 break;
183 default:
184 jj_la1[2] = jj_gen;
185 break label_2;
186 }
187 TypeDeclaration();
188 }
189 jj_consume_token(0);
190
191
192
193
194 if( _sourceClassStack.size() != 0 ) {
195 {if (true) throw new IllegalStateException("There should be no more classes on the stack:" + _sourceClassStack.size());}
196 }
197 }
198
199 final public void PackageDeclaration() throws ParseException {
200 jj_consume_token(PACKAGE);
201 _packageName = Name();
202 jj_consume_token(SEMICOLON);
203 _sourceClass.setContainingPackage( _packageName );
204 }
205
206 final public void ImportDeclaration() throws ParseException {
207 String importedElement;
208 boolean isPackage = false;
209 jj_consume_token(IMPORT);
210 importedElement = Name();
211 switch (jj_nt.kind) {
212 case DOT:
213 jj_consume_token(DOT);
214 jj_consume_token(STAR);
215 isPackage = true;
216 break;
217 default:
218 jj_la1[3] = jj_gen;
219 ;
220 }
221 jj_consume_token(SEMICOLON);
222 if( isPackage ) {
223 _sourceClass.addImportedPackage(importedElement);
224 } else {
225 _sourceClass.addImportedClass(importedElement);
226 }
227 }
228
229 final public void TypeDeclaration() throws ParseException {
230 if (jj_2_1(2147483647)) {
231 ClassDeclaration();
232 _hasParsedMain = true;
233 } else {
234 switch (jj_nt.kind) {
235 case ABSTRACT:
236 case INTERFACE:
237 case PUBLIC:
238 case STRICTFP:
239 InterfaceDeclaration();
240 _hasParsedMain = true;
241 break;
242 case SEMICOLON:
243 jj_consume_token(SEMICOLON);
244 break;
245 default:
246 jj_la1[4] = jj_gen;
247 jj_consume_token(-1);
248 throw new ParseException();
249 }
250 }
251 }
252
253
254
255
256
257
258
259
260
261
262 final public void ClassDeclaration() throws ParseException {
263 SourceClass sourceClass = pushAndGet();
264 Token t = null;
265 label_3:
266 while (true) {
267 switch (jj_nt.kind) {
268 case ABSTRACT:
269 case FINAL:
270 case PUBLIC:
271 case STRICTFP:
272 ;
273 break;
274 default:
275 jj_la1[5] = jj_gen;
276 break label_3;
277 }
278 switch (jj_nt.kind) {
279 case ABSTRACT:
280 t = jj_consume_token(ABSTRACT);
281 setToken(sourceClass, t);
282 sourceClass.addModifier( Modifier.ABSTRACT );
283 break;
284 case FINAL:
285 t = jj_consume_token(FINAL);
286 setToken(sourceClass, t);
287 sourceClass.addModifier( Modifier.FINAL );
288 break;
289 case PUBLIC:
290 t = jj_consume_token(PUBLIC);
291 setToken(sourceClass, t);
292 sourceClass.addModifier( Modifier.PUBLIC );
293 break;
294 case STRICTFP:
295 t = jj_consume_token(STRICTFP);
296 setToken(sourceClass, t);
297 sourceClass.addModifier( Modifier.STRICT );
298 break;
299 default:
300 jj_la1[6] = jj_gen;
301 jj_consume_token(-1);
302 throw new ParseException();
303 }
304 }
305 UnmodifiedClassDeclaration();
306 popAndAddInner();
307 }
308
309 final public void UnmodifiedClassDeclaration() throws ParseException {
310
311 SourceClass sourceClass = currentClass();
312
313 Token ct;
314 Token name = null;
315 String superclass = null;
316 ct = jj_consume_token(CLASS);
317 if(sourceClass!=null) {
318 setToken( sourceClass, ct );
319 sourceClass.setInterface( false );
320 }
321 name = jj_consume_token(IDENTIFIER);
322 if(sourceClass.isInner()) {
323 sourceClass.setName(name.image);
324 _xJavaDoc.addPackageMaybe( _packageName ).addClass(sourceClass);
325 _xJavaDoc.addSourceClass( sourceClass );
326 } else {
327 sourceClass.setQualifiedName(Util.getQualifiedNameFor(_packageName,name.image));
328 _xJavaDoc.addPackageMaybe( _packageName ).addClass(sourceClass);
329 _xJavaDoc.addSourceClass( sourceClass );
330 sourceClass.resolveImportedClasses();
331
332
333 _xJavaDoc.addSourceClass(sourceClass);
334 }
335 switch (jj_nt.kind) {
336 case EXTENDS:
337 jj_consume_token(EXTENDS);
338 superclass = Name();
339 break;
340 default:
341 jj_la1[7] = jj_gen;
342 ;
343 }
344 switch (jj_nt.kind) {
345 case IMPLEMENTS:
346 jj_consume_token(IMPLEMENTS);
347 Interfaces_NameList();
348 break;
349 default:
350 jj_la1[8] = jj_gen;
351 ;
352 }
353 ClassBody();
354 if( superclass != null ) {
355 sourceClass.setSuperclass(superclass);
356 } else {
357 sourceClass.setSuperclass("java.lang.Object");
358 }
359 }
360
361 final public void ClassBody() throws ParseException {
362 jj_consume_token(LBRACE);
363 label_4:
364 while (true) {
365 switch (jj_nt.kind) {
366 case ABSTRACT:
367 case BOOLEAN:
368 case BYTE:
369 case CHAR:
370 case CLASS:
371 case DOUBLE:
372 case FINAL:
373 case FLOAT:
374 case INT:
375 case INTERFACE:
376 case LONG:
377 case NATIVE:
378 case PRIVATE:
379 case PROTECTED:
380 case PUBLIC:
381 case SHORT:
382 case STATIC:
383 case SYNCHRONIZED:
384 case TRANSIENT:
385 case VOID:
386 case VOLATILE:
387 case STRICTFP:
388 case IDENTIFIER:
389 case LBRACE:
390 ;
391 break;
392 default:
393 jj_la1[9] = jj_gen;
394 break label_4;
395 }
396 ClassBodyDeclaration();
397 }
398 jj_consume_token(RBRACE);
399 }
400
401 final public void NestedClassDeclaration() throws ParseException {
402 SourceClass sourceClass = pushAndGet();
403 Token t;
404 label_5:
405 while (true) {
406 switch (jj_nt.kind) {
407 case ABSTRACT:
408 case FINAL:
409 case PRIVATE:
410 case PROTECTED:
411 case PUBLIC:
412 case STATIC:
413 case STRICTFP:
414 ;
415 break;
416 default:
417 jj_la1[10] = jj_gen;
418 break label_5;
419 }
420 switch (jj_nt.kind) {
421 case STATIC:
422 t = jj_consume_token(STATIC);
423 sourceClass.addModifier( Modifier.STATIC );
424 sourceClass.setToken( t );
425 break;
426 case ABSTRACT:
427 t = jj_consume_token(ABSTRACT);
428 sourceClass.addModifier( Modifier.ABSTRACT );
429 sourceClass.setToken( t );
430 break;
431 case FINAL:
432 t = jj_consume_token(FINAL);
433 sourceClass.addModifier( Modifier.FINAL );
434 sourceClass.setToken( t );
435 break;
436 case PUBLIC:
437 t = jj_consume_token(PUBLIC);
438 sourceClass.addModifier( Modifier.PUBLIC );
439 sourceClass.setToken( t );
440 break;
441 case PROTECTED:
442 t = jj_consume_token(PROTECTED);
443 sourceClass.addModifier( Modifier.PROTECTED );
444 sourceClass.setToken( t );
445 break;
446 case PRIVATE:
447 t = jj_consume_token(PRIVATE);
448 sourceClass.addModifier( Modifier.PRIVATE );
449 sourceClass.setToken( t );
450 break;
451 case STRICTFP:
452 t = jj_consume_token(STRICTFP);
453 sourceClass.addModifier( Modifier.STRICT );
454 sourceClass.setToken( t );
455 break;
456 default:
457 jj_la1[11] = jj_gen;
458 jj_consume_token(-1);
459 throw new ParseException();
460 }
461 }
462 UnmodifiedClassDeclaration();
463 popAndAddInner();
464 }
465
466 final public void ClassBodyDeclaration() throws ParseException {
467 SourceClass sourceClass = currentClass();
468 if (jj_2_2(2)) {
469 Initializer();
470 } else if (jj_2_3(2147483647)) {
471 NestedClassDeclaration();
472 } else if (jj_2_4(2147483647)) {
473 NestedInterfaceDeclaration();
474 } else if (jj_2_5(2147483647)) {
475 ConstructorDeclaration();
476 } else if (jj_2_6(2147483647)) {
477 MethodDeclaration();
478 } else {
479 switch (jj_nt.kind) {
480 case BOOLEAN:
481 case BYTE:
482 case CHAR:
483 case DOUBLE:
484 case FINAL:
485 case FLOAT:
486 case INT:
487 case LONG:
488 case PRIVATE:
489 case PROTECTED:
490 case PUBLIC:
491 case SHORT:
492 case STATIC:
493 case TRANSIENT:
494 case VOLATILE:
495 case IDENTIFIER:
496 FieldDeclaration();
497 break;
498 default:
499 jj_la1[12] = jj_gen;
500 jj_consume_token(-1);
501 throw new ParseException();
502 }
503 }
504 }
505
506
507 final public void MethodDeclarationLookahead() throws ParseException {
508 label_6:
509 while (true) {
510 switch (jj_nt.kind) {
511 case ABSTRACT:
512 case FINAL:
513 case NATIVE:
514 case PRIVATE:
515 case PROTECTED:
516 case PUBLIC:
517 case STATIC:
518 case SYNCHRONIZED:
519 case STRICTFP:
520 ;
521 break;
522 default:
523 jj_la1[13] = jj_gen;
524 break label_6;
525 }
526 switch (jj_nt.kind) {
527 case PUBLIC:
528 jj_consume_token(PUBLIC);
529 break;
530 case PROTECTED:
531 jj_consume_token(PROTECTED);
532 break;
533 case PRIVATE:
534 jj_consume_token(PRIVATE);
535 break;
536 case STATIC:
537 jj_consume_token(STATIC);
538 break;
539 case ABSTRACT:
540 jj_consume_token(ABSTRACT);
541 break;
542 case FINAL:
543 jj_consume_token(FINAL);
544 break;
545 case NATIVE:
546 jj_consume_token(NATIVE);
547 break;
548 case SYNCHRONIZED:
549 jj_consume_token(SYNCHRONIZED);
550 break;
551 case STRICTFP:
552 jj_consume_token(STRICTFP);
553 break;
554 default:
555 jj_la1[14] = jj_gen;
556 jj_consume_token(-1);
557 throw new ParseException();
558 }
559 }
560 ResultType(null);
561 jj_consume_token(IDENTIFIER);
562 jj_consume_token(LPAREN);
563 }
564
565 final public void InterfaceDeclaration() throws ParseException {
566 SourceClass sourceClass = pushAndGet();
567 Token t = null;
568 label_7:
569 while (true) {
570 switch (jj_nt.kind) {
571 case ABSTRACT:
572 case PUBLIC:
573 case STRICTFP:
574 ;
575 break;
576 default:
577 jj_la1[15] = jj_gen;
578 break label_7;
579 }
580 switch (jj_nt.kind) {
581 case ABSTRACT:
582 t = jj_consume_token(ABSTRACT);
583 sourceClass.addModifier( Modifier.ABSTRACT );
584 sourceClass.setToken( t );
585 break;
586 case PUBLIC:
587 t = jj_consume_token(PUBLIC);
588 sourceClass.addModifier( Modifier.PUBLIC );
589 sourceClass.setToken( t );
590 break;
591 case STRICTFP:
592 t = jj_consume_token(STRICTFP);
593 sourceClass.addModifier( Modifier.STRICT );
594 sourceClass.setToken( t );
595 break;
596 default:
597 jj_la1[16] = jj_gen;
598 jj_consume_token(-1);
599 throw new ParseException();
600 }
601 }
602 UnmodifiedInterfaceDeclaration();
603 popAndAddInner();
604 }
605
606 final public void NestedInterfaceDeclaration() throws ParseException {
607 SourceClass sourceClass = pushAndGet();
608 Token t;
609 label_8:
610 while (true) {
611 switch (jj_nt.kind) {
612 case ABSTRACT:
613 case FINAL:
614 case PRIVATE:
615 case PROTECTED:
616 case PUBLIC:
617 case STATIC:
618 case STRICTFP:
619 ;
620 break;
621 default:
622 jj_la1[17] = jj_gen;
623 break label_8;
624 }
625 switch (jj_nt.kind) {
626 case STATIC:
627 t = jj_consume_token(STATIC);
628 sourceClass.addModifier( Modifier.STATIC );
629 sourceClass.setToken( t );
630 break;
631 case ABSTRACT:
632 t = jj_consume_token(ABSTRACT);
633 sourceClass.addModifier( Modifier.ABSTRACT );
634 sourceClass.setToken( t );
635 break;
636 case FINAL:
637 t = jj_consume_token(FINAL);
638 sourceClass.addModifier( Modifier.FINAL );
639 sourceClass.setToken( t );
640 break;
641 case PUBLIC:
642 t = jj_consume_token(PUBLIC);
643 sourceClass.addModifier( Modifier.PUBLIC );
644 sourceClass.setToken( t );
645 break;
646 case PROTECTED:
647 t = jj_consume_token(PROTECTED);
648 sourceClass.addModifier( Modifier.PROTECTED );
649 sourceClass.setToken( t );
650 break;
651 case PRIVATE:
652 t = jj_consume_token(PRIVATE);
653 sourceClass.addModifier( Modifier.PRIVATE );
654 sourceClass.setToken( t );
655 break;
656 case STRICTFP:
657 t = jj_consume_token(STRICTFP);
658 sourceClass.addModifier( Modifier.STRICT );
659 sourceClass.setToken( t );
660 break;
661 default:
662 jj_la1[18] = jj_gen;
663 jj_consume_token(-1);
664 throw new ParseException();
665 }
666 }
667 UnmodifiedInterfaceDeclaration();
668 popAndAddInner();
669 }
670
671 final public void UnmodifiedInterfaceDeclaration() throws ParseException {
672 SourceClass sourceClass = currentClass();
673 Token it;
674 Token name = null;
675 it = jj_consume_token(INTERFACE);
676 name = jj_consume_token(IDENTIFIER);
677
678 sourceClass.addModifier( Modifier.ABSTRACT );
679
680 if(sourceClass.isInner()) {
681 sourceClass.setName(name.image);
682 _xJavaDoc.addPackageMaybe( _packageName ).addClass(sourceClass);
683 _xJavaDoc.addSourceClass( sourceClass );
684 } else {
685 sourceClass.setQualifiedName(Util.getQualifiedNameFor(_packageName,name.image));
686 _xJavaDoc.addPackageMaybe( _packageName ).addClass(sourceClass);
687 _xJavaDoc.addSourceClass( sourceClass );
688 sourceClass.resolveImportedClasses();
689 }
690
691 sourceClass.setInterface( true );
692 setToken(sourceClass,it);
693 switch (jj_nt.kind) {
694 case EXTENDS:
695 jj_consume_token(EXTENDS);
696 Interfaces_NameList();
697 break;
698 default:
699 jj_la1[19] = jj_gen;
700 ;
701 }
702 jj_consume_token(LBRACE);
703 label_9:
704 while (true) {
705 switch (jj_nt.kind) {
706 case ABSTRACT:
707 case BOOLEAN:
708 case BYTE:
709 case CHAR:
710 case CLASS:
711 case DOUBLE:
712 case FINAL:
713 case FLOAT:
714 case INT:
715 case INTERFACE:
716 case LONG:
717 case NATIVE:
718 case PRIVATE:
719 case PROTECTED:
720 case PUBLIC:
721 case SHORT:
722 case STATIC:
723 case SYNCHRONIZED:
724 case TRANSIENT:
725 case VOID:
726 case VOLATILE:
727 case STRICTFP:
728 case IDENTIFIER:
729 ;
730 break;
731 default:
732 jj_la1[20] = jj_gen;
733 break label_9;
734 }
735 InterfaceMemberDeclaration();
736 }
737 jj_consume_token(RBRACE);
738 if(sourceClass.isInner()) {
739 sourceClass.setName(name.image);
740 }
741 }
742
743 final public void InterfaceMemberDeclaration() throws ParseException {
744 if (jj_2_7(2147483647)) {
745 NestedClassDeclaration();
746 } else if (jj_2_8(2147483647)) {
747 NestedInterfaceDeclaration();
748 } else if (jj_2_9(2147483647)) {
749 MethodDeclaration();
750 } else {
751 switch (jj_nt.kind) {
752 case BOOLEAN:
753 case BYTE:
754 case CHAR:
755 case DOUBLE:
756 case FINAL:
757 case FLOAT:
758 case INT:
759 case LONG:
760 case PRIVATE:
761 case PROTECTED:
762 case PUBLIC:
763 case SHORT:
764 case STATIC:
765 case TRANSIENT:
766 case VOLATILE:
767 case IDENTIFIER:
768 FieldDeclaration();
769 break;
770 default:
771 jj_la1[21] = jj_gen;
772 jj_consume_token(-1);
773 throw new ParseException();
774 }
775 }
776 }
777
778 final public void FieldDeclaration() throws ParseException {
779 SourceClass sourceClass = currentClass();
780
781
782
783
784
785
786
787
788 Token t = null;
789 FieldImpl fieldImpl = null;
790 fieldImpl = new FieldImpl(sourceClass, _tagFactory);
791 label_10:
792 while (true) {
793 switch (jj_nt.kind) {
794 case FINAL:
795 case PRIVATE:
796 case PROTECTED:
797 case PUBLIC:
798 case STATIC:
799 case TRANSIENT:
800 case VOLATILE:
801 ;
802 break;
803 default:
804 jj_la1[22] = jj_gen;
805 break label_10;
806 }
807 switch (jj_nt.kind) {
808 case PUBLIC:
809 t = jj_consume_token(PUBLIC);
810 fieldImpl.addModifier( Modifier.PUBLIC );
811 setToken(fieldImpl,t);
812 break;
813 case PROTECTED:
814 t = jj_consume_token(PROTECTED);
815 fieldImpl.addModifier( Modifier.PROTECTED );
816 setToken(fieldImpl,t);
817 break;
818 case PRIVATE:
819 t = jj_consume_token(PRIVATE);
820 fieldImpl.addModifier( Modifier.PRIVATE );
821 setToken(fieldImpl,t);
822 break;
823 case STATIC:
824 t = jj_consume_token(STATIC);
825 fieldImpl.addModifier( Modifier.STATIC );
826 setToken(fieldImpl,t);
827 break;
828 case FINAL:
829 t = jj_consume_token(FINAL);
830 fieldImpl.addModifier( Modifier.FINAL );
831 setToken(fieldImpl,t);
832 break;
833 case TRANSIENT:
834 t = jj_consume_token(TRANSIENT);
835 fieldImpl.addModifier( Modifier.TRANSIENT );
836 setToken(fieldImpl,t);
837 break;
838 case VOLATILE:
839 t = jj_consume_token(VOLATILE);
840 fieldImpl.addModifier( Modifier.VOLATILE );
841 setToken(fieldImpl,t);
842 break;
843 default:
844 jj_la1[23] = jj_gen;
845 jj_consume_token(-1);
846 throw new ParseException();
847 }
848 }
849 Field_Type(fieldImpl);
850 FieldDeclarator(fieldImpl);
851 label_11:
852 while (true) {
853 switch (jj_nt.kind) {
854 case COMMA:
855 ;
856 break;
857 default:
858 jj_la1[24] = jj_gen;
859 break label_11;
860 }
861 jj_consume_token(COMMA);
862 FieldImpl badProgrammingStyleFieldImpl = new FieldImpl(sourceClass, _tagFactory);
863 badProgrammingStyleFieldImpl.setType(fieldImpl.getTypeAsString());
864 FieldDeclarator(badProgrammingStyleFieldImpl);
865 sourceClass.addField(badProgrammingStyleFieldImpl);
866 }
867 jj_consume_token(SEMICOLON);
868
869 sourceClass.addField(fieldImpl);
870 }
871
872 final public void FieldDeclarator(FieldImpl fieldImpl) throws ParseException {
873 Field_VariableDeclaratorId(fieldImpl);
874 switch (jj_nt.kind) {
875 case ASSIGN:
876 jj_consume_token(ASSIGN);
877 VariableInitializer();
878 break;
879 default:
880 jj_la1[25] = jj_gen;
881 ;
882 }
883 }
884
885 final public void VariableDeclarator() throws ParseException {
886 VariableDeclaratorId();
887 switch (jj_nt.kind) {
888 case ASSIGN:
889 jj_consume_token(ASSIGN);
890 VariableInitializer();
891 break;
892 default:
893 jj_la1[26] = jj_gen;
894 ;
895 }
896 }
897
898 final public void Field_VariableDeclaratorId(FieldImpl fieldImpl) throws ParseException {
899 Token t = null;
900 t = jj_consume_token(IDENTIFIER);
901 label_12:
902 while (true) {
903 switch (jj_nt.kind) {
904 case LBRACKET:
905 ;
906 break;
907 default:
908 jj_la1[27] = jj_gen;
909 break label_12;
910 }
911 jj_consume_token(LBRACKET);
912 jj_consume_token(RBRACKET);
913 fieldImpl.setDimension(fieldImpl.getDimension() + 1);
914 }
915 fieldImpl.setName( t.image );
916 }
917
918 final public void Parameter_VariableDeclaratorId() throws ParseException {
919 Token t = null;
920 t = jj_consume_token(IDENTIFIER);
921 label_13:
922 while (true) {
923 switch (jj_nt.kind) {
924 case LBRACKET:
925 ;
926 break;
927 default:
928 jj_la1[28] = jj_gen;
929 break label_13;
930 }
931 jj_consume_token(LBRACKET);
932 jj_consume_token(RBRACKET);
933 _parameter.dimension++;
934 }
935 _parameter.name = t.image;
936 }
937
938 final public void VariableDeclaratorId() throws ParseException {
939 jj_consume_token(IDENTIFIER);
940 label_14:
941 while (true) {
942 switch (jj_nt.kind) {
943 case LBRACKET:
944 ;
945 break;
946 default:
947 jj_la1[29] = jj_gen;
948 break label_14;
949 }
950 jj_consume_token(LBRACKET);
951 jj_consume_token(RBRACKET);
952 }
953 }
954
955 final public void VariableInitializer() throws ParseException {
956 switch (jj_nt.kind) {
957 case LBRACE:
958 ArrayInitializer();
959 break;
960 case BOOLEAN:
961 case BYTE:
962 case CHAR:
963 case DOUBLE:
964 case FALSE:
965 case FLOAT:
966 case INT:
967 case LONG:
968 case NEW:
969 case NULL:
970 case SHORT:
971 case SUPER:
972 case THIS:
973 case TRUE:
974 case VOID:
975 case INTEGER_LITERAL:
976 case FLOATING_POINT_LITERAL:
977 case CHARACTER_LITERAL:
978 case STRING_LITERAL:
979 case IDENTIFIER:
980 case LPAREN:
981 case BANG:
982 case TILDE:
983 case INCR:
984 case DECR:
985 case PLUS:
986 case MINUS:
987 Expression();
988 break;
989 default:
990 jj_la1[30] = jj_gen;
991 jj_consume_token(-1);
992 throw new ParseException();
993 }
994 }
995
996 final public void ArrayInitializer() throws ParseException {
997 jj_consume_token(LBRACE);
998 switch (jj_nt.kind) {
999 case BOOLEAN:
1000 case BYTE:
1001 case CHAR:
1002 case DOUBLE:
1003 case FALSE:
1004 case FLOAT:
1005 case INT:
1006 case LONG:
1007 case NEW:
1008 case NULL:
1009 case SHORT:
1010 case SUPER:
1011 case THIS:
1012 case TRUE:
1013 case VOID:
1014 case INTEGER_LITERAL:
1015 case FLOATING_POINT_LITERAL:
1016 case CHARACTER_LITERAL:
1017 case STRING_LITERAL:
1018 case IDENTIFIER:
1019 case LPAREN:
1020 case LBRACE:
1021 case BANG:
1022 case TILDE:
1023 case INCR:
1024 case DECR:
1025 case PLUS:
1026 case MINUS:
1027 VariableInitializer();
1028 label_15:
1029 while (true) {
1030 if (jj_2_10(2)) {
1031 ;
1032 } else {
1033 break label_15;
1034 }
1035 jj_consume_token(COMMA);
1036 VariableInitializer();
1037 }
1038 break;
1039 default:
1040 jj_la1[31] = jj_gen;
1041 ;
1042 }
1043 switch (jj_nt.kind) {
1044 case COMMA:
1045 jj_consume_token(COMMA);
1046 break;
1047 default:
1048 jj_la1[32] = jj_gen;
1049 ;
1050 }
1051 jj_consume_token(RBRACE);
1052 }
1053
1054 final public void MethodDeclaration() throws ParseException {
1055 SourceClass sourceClass = currentClass();
1056
1057 Token t = null;
1058 String exceptions = null;
1059
1060
1061 MethodImpl methodImpl = null;
1062
1063 if(sourceClass!=null) {
1064 methodImpl = new MethodImpl(sourceClass, _tagFactory);
1065 }
1066 label_16:
1067 while (true) {
1068 switch (jj_nt.kind) {
1069 case ABSTRACT:
1070 case FINAL:
1071 case NATIVE:
1072 case PRIVATE:
1073 case PROTECTED:
1074 case PUBLIC:
1075 case STATIC:
1076 case SYNCHRONIZED:
1077 case STRICTFP:
1078 ;
1079 break;
1080 default:
1081 jj_la1[33] = jj_gen;
1082 break label_16;
1083 }
1084 switch (jj_nt.kind) {
1085 case PUBLIC:
1086 t = jj_consume_token(PUBLIC);
1087 if(methodImpl!=null) {
1088 methodImpl.addModifier( Modifier.PUBLIC );
1089 setToken( methodImpl, t );
1090 }
1091 break;
1092 case PROTECTED:
1093 t = jj_consume_token(PROTECTED);
1094 if(methodImpl!=null) {
1095 methodImpl.addModifier( Modifier.PROTECTED );
1096 setToken( methodImpl, t );
1097 }
1098 break;
1099 case PRIVATE:
1100 t = jj_consume_token(PRIVATE);
1101 if(methodImpl!=null) {
1102 methodImpl.addModifier( Modifier.PRIVATE );
1103 setToken( methodImpl, t );
1104 }
1105 break;
1106 case STATIC:
1107 t = jj_consume_token(STATIC);
1108 if(methodImpl!=null) {
1109 methodImpl.addModifier( Modifier.STATIC );
1110 setToken( methodImpl, t );
1111 }
1112 break;
1113 case ABSTRACT:
1114 t = jj_consume_token(ABSTRACT);
1115 if(methodImpl!=null) {
1116 methodImpl.addModifier( Modifier.ABSTRACT );
1117 setToken( methodImpl, t );
1118 }
1119 break;
1120 case FINAL:
1121 t = jj_consume_token(FINAL);
1122 if(methodImpl!=null) {
1123 methodImpl.addModifier( Modifier.FINAL );
1124 setToken( methodImpl, t );
1125 }
1126 break;
1127 case NATIVE:
1128 t = jj_consume_token(NATIVE);
1129 if(methodImpl!=null) {
1130 methodImpl.addModifier( Modifier.NATIVE );
1131 setToken( methodImpl, t );
1132 }
1133 break;
1134 case SYNCHRONIZED:
1135 t = jj_consume_token(SYNCHRONIZED);
1136 if(methodImpl!=null) {
1137 methodImpl.addModifier( Modifier.SYNCHRONIZED );
1138 setToken( methodImpl, t );
1139 }
1140 break;
1141 case STRICTFP:
1142 t = jj_consume_token(STRICTFP);
1143 if(methodImpl!=null) {
1144 methodImpl.addModifier( Modifier.STRICT );
1145 setToken( methodImpl, t );
1146 }
1147 break;
1148 default:
1149 jj_la1[34] = jj_gen;
1150 jj_consume_token(-1);
1151 throw new ParseException();
1152 }
1153 }
1154 ResultType(methodImpl);
1155 MethodDeclarator(methodImpl);
1156 switch (jj_nt.kind) {
1157 case THROWS:
1158 jj_consume_token(THROWS);
1159 ExecutableMemberThrows_NameList(methodImpl);
1160 break;
1161 default:
1162 jj_la1[35] = jj_gen;
1163 ;
1164 }
1165 switch (jj_nt.kind) {
1166 case LBRACE:
1167 Method_Block();
1168 break;
1169 case SEMICOLON:
1170 jj_consume_token(SEMICOLON);
1171 break;
1172 default:
1173 jj_la1[36] = jj_gen;
1174 jj_consume_token(-1);
1175 throw new ParseException();
1176 }
1177
1178
1179 sourceClass.addMethod(methodImpl);
1180 }
1181
1182 final public void MethodDeclarator(MethodImpl methodImpl) throws ParseException {
1183 Token t = null;
1184 t = jj_consume_token(IDENTIFIER);
1185 if( methodImpl != null ) {
1186 methodImpl.setName( t.image );
1187 }
1188 FormalParameters(methodImpl);
1189 label_17:
1190 while (true) {
1191 switch (jj_nt.kind) {
1192 case LBRACKET:
1193 ;
1194 break;
1195 default:
1196 jj_la1[37] = jj_gen;
1197 break label_17;
1198 }
1199 jj_consume_token(LBRACKET);
1200 jj_consume_token(RBRACKET);
1201 methodImpl.setReturnDimension( methodImpl.getReturnType().getDimension() + 1 );
1202 }
1203 }
1204
1205 final public void FormalParameters(AbstractExecutableMember member) throws ParseException {
1206 jj_consume_token(LPAREN);
1207 switch (jj_nt.kind) {
1208 case BOOLEAN:
1209 case BYTE:
1210 case CHAR:
1211 case DOUBLE:
1212 case FINAL:
1213 case FLOAT:
1214 case INT:
1215 case LONG:
1216 case SHORT:
1217 case IDENTIFIER:
1218 FormalParameter(member);
1219 label_18:
1220 while (true) {
1221 switch (jj_nt.kind) {
1222 case COMMA:
1223 ;
1224 break;
1225 default:
1226 jj_la1[38] = jj_gen;
1227 break label_18;
1228 }
1229 jj_consume_token(COMMA);
1230 FormalParameter(member);
1231 }
1232 break;
1233 default:
1234 jj_la1[39] = jj_gen;
1235 ;
1236 }
1237 jj_consume_token(RPAREN);
1238 }
1239
1240 final public void FormalParameter(AbstractExecutableMember member) throws ParseException {
1241 if(member != null) {
1242
1243 _parameter.dimension = 0;
1244 }
1245 switch (jj_nt.kind) {
1246 case FINAL:
1247 jj_consume_token(FINAL);
1248 break;
1249 default:
1250 jj_la1[40] = jj_gen;
1251 ;
1252 }
1253 Parameter_Type();
1254 Parameter_VariableDeclaratorId();
1255 if( member != null ) {
1256 member.addParameterData(_parameter.type, _parameter.name, _parameter.dimension);
1257 }
1258 }
1259
1260 final public void ConstructorDeclaration() throws ParseException {
1261 SourceClass sourceClass = currentClass();
1262 Token t = null;
1263 ConstructorImpl constructor = constructor = new ConstructorImpl(sourceClass, _tagFactory);
1264 switch (jj_nt.kind) {
1265 case PRIVATE:
1266 case PROTECTED:
1267 case PUBLIC:
1268 switch (jj_nt.kind) {
1269 case PUBLIC:
1270 t = jj_consume_token(PUBLIC);
1271 constructor.addModifier( Modifier.PUBLIC );
1272 setToken( constructor, t );
1273 break;
1274 case PROTECTED:
1275 t = jj_consume_token(PROTECTED);
1276 constructor.addModifier( Modifier.PROTECTED );
1277 setToken( constructor, t );
1278 break;
1279 case PRIVATE:
1280 t = jj_consume_token(PRIVATE);
1281 constructor.addModifier( Modifier.PRIVATE );
1282 setToken( constructor, t );
1283 break;
1284 default:
1285 jj_la1[41] = jj_gen;
1286 jj_consume_token(-1);
1287 throw new ParseException();
1288 }
1289 break;
1290 default:
1291 jj_la1[42] = jj_gen;
1292 ;
1293 }
1294 jj_consume_token(IDENTIFIER);
1295 FormalParameters(constructor);
1296 switch (jj_nt.kind) {
1297 case THROWS:
1298 jj_consume_token(THROWS);
1299 ExecutableMemberThrows_NameList(constructor);
1300 break;
1301 default:
1302 jj_la1[43] = jj_gen;
1303 ;
1304 }
1305 jj_consume_token(LBRACE);
1306 if (jj_2_11(2147483647)) {
1307 ExplicitConstructorInvocation();
1308 } else {
1309 ;
1310 }
1311 label_19:
1312 while (true) {
1313 switch (jj_nt.kind) {
1314 case BOOLEAN:
1315 case BREAK:
1316 case BYTE:
1317 case CHAR:
1318 case CLASS:
1319 case CONTINUE:
1320 case DO:
1321 case DOUBLE:
1322 case FALSE:
1323 case FINAL:
1324 case FLOAT:
1325 case FOR:
1326 case IF:
1327 case INT:
1328 case INTERFACE:
1329 case LONG:
1330 case NEW:
1331 case NULL:
1332 case RETURN:
1333 case SHORT:
1334 case SUPER:
1335 case SWITCH:
1336 case SYNCHRONIZED:
1337 case THIS:
1338 case THROW:
1339 case TRUE:
1340 case TRY:
1341 case VOID:
1342 case WHILE:
1343 case ASSERT:
1344 case INTEGER_LITERAL:
1345 case FLOATING_POINT_LITERAL:
1346 case CHARACTER_LITERAL:
1347 case STRING_LITERAL:
1348 case IDENTIFIER:
1349 case LPAREN:
1350 case LBRACE:
1351 case SEMICOLON:
1352 case INCR:
1353 case DECR:
1354 ;
1355 break;
1356 default:
1357 jj_la1[44] = jj_gen;
1358 break label_19;
1359 }
1360 BlockStatement();
1361 }
1362 jj_consume_token(RBRACE);
1363
1364
1365 sourceClass.addConstructor(constructor);
1366 }
1367
1368 final public void ExplicitConstructorInvocation() throws ParseException {
1369 if (jj_2_13(2147483647)) {
1370 jj_consume_token(THIS);
1371 Arguments();
1372 jj_consume_token(SEMICOLON);
1373 } else {
1374 switch (jj_nt.kind) {
1375 case BOOLEAN:
1376 case BYTE:
1377 case CHAR:
1378 case DOUBLE:
1379 case FALSE:
1380 case FLOAT:
1381 case INT:
1382 case LONG:
1383 case NEW:
1384 case NULL:
1385 case SHORT:
1386 case SUPER:
1387 case THIS:
1388 case TRUE:
1389 case VOID:
1390 case INTEGER_LITERAL:
1391 case FLOATING_POINT_LITERAL:
1392 case CHARACTER_LITERAL:
1393 case STRING_LITERAL:
1394 case IDENTIFIER:
1395 case LPAREN:
1396 if (jj_2_12(2)) {
1397 PrimaryExpression();
1398 jj_consume_token(DOT);
1399 } else {
1400 ;
1401 }
1402 jj_consume_token(SUPER);
1403 Arguments();
1404 jj_consume_token(SEMICOLON);
1405 break;
1406 default:
1407 jj_la1[45] = jj_gen;
1408 jj_consume_token(-1);
1409 throw new ParseException();
1410 }
1411 }
1412 }
1413
1414 final public void Initializer() throws ParseException {
1415 switch (jj_nt.kind) {
1416 case STATIC:
1417 jj_consume_token(STATIC);
1418 break;
1419 default:
1420 jj_la1[46] = jj_gen;
1421 ;
1422 }
1423 Block();
1424 }
1425
1426
1427
1428
1429 final public void Field_Type(FieldImpl fieldImpl) throws ParseException {
1430 Token typeToken;
1431 String type;
1432 switch (jj_nt.kind) {
1433 case BOOLEAN:
1434 case BYTE:
1435 case CHAR:
1436 case DOUBLE:
1437 case FLOAT:
1438 case INT:
1439 case LONG:
1440 case SHORT:
1441 typeToken = PrimitiveType();
1442 if( fieldImpl != null ) {
1443 fieldImpl.setType(typeToken.image);
1444 setToken( fieldImpl, typeToken );
1445 }
1446 break;
1447 case IDENTIFIER:
1448 type = Name();
1449 if( fieldImpl != null ) {
1450 fieldImpl.setType(type);
1451 setToken( fieldImpl, _nameToken );
1452 }
1453 break;
1454 default:
1455 jj_la1[47] = jj_gen;
1456 jj_consume_token(-1);
1457 throw new ParseException();
1458 }
1459 label_20:
1460 while (true) {
1461 switch (jj_nt.kind) {
1462 case LBRACKET:
1463 ;
1464 break;
1465 default:
1466 jj_la1[48] = jj_gen;
1467 break label_20;
1468 }
1469 jj_consume_token(LBRACKET);
1470 jj_consume_token(RBRACKET);
1471 if( fieldImpl != null ) {
1472 fieldImpl.setDimension(fieldImpl.getDimension() + 1);
1473 }
1474 }
1475 }
1476
1477 final public void MethodResult_Type(MethodImpl methodImpl) throws ParseException {
1478 Token typeToken;
1479 String type;
1480 switch (jj_nt.kind) {
1481 case BOOLEAN:
1482 case BYTE:
1483 case CHAR:
1484 case DOUBLE:
1485 case FLOAT:
1486 case INT:
1487 case LONG:
1488 case SHORT:
1489 typeToken = PrimitiveType();
1490 if( methodImpl != null ) {
1491 methodImpl.setReturnType(typeToken.image);
1492 setToken( methodImpl, typeToken );
1493 }
1494 break;
1495 case IDENTIFIER:
1496 type = Name();
1497 if( methodImpl != null ) {
1498 methodImpl.setReturnType(type);
1499 setToken( methodImpl, _nameToken );
1500 }
1501 break;
1502 default:
1503 jj_la1[49] = jj_gen;
1504 jj_consume_token(-1);
1505 throw new ParseException();
1506 }
1507 label_21:
1508 while (true) {
1509 switch (jj_nt.kind) {
1510 case LBRACKET:
1511 ;
1512 break;
1513 default:
1514 jj_la1[50] = jj_gen;
1515 break label_21;
1516 }
1517 jj_consume_token(LBRACKET);
1518 jj_consume_token(RBRACKET);
1519 if( methodImpl != null ) {
1520 methodImpl.setReturnDimension(methodImpl.getReturnType().getDimension() + 1);
1521 }
1522 }
1523 }
1524
1525 final public void Parameter_Type() throws ParseException {
1526 Token primitive;
1527 String name;
1528 switch (jj_nt.kind) {
1529 case BOOLEAN:
1530 case BYTE:
1531 case CHAR:
1532 case DOUBLE:
1533 case FLOAT:
1534 case INT:
1535 case LONG:
1536 case SHORT:
1537 primitive = PrimitiveType();
1538 _parameter.type = primitive.image;
1539 break;
1540 case IDENTIFIER:
1541 name = Name();
1542 _parameter.type = name;
1543 break;
1544 default:
1545 jj_la1[51] = jj_gen;
1546 jj_consume_token(-1);
1547 throw new ParseException();
1548 }
1549 label_22:
1550 while (true) {
1551 switch (jj_nt.kind) {
1552 case LBRACKET:
1553 ;
1554 break;
1555 default:
1556 jj_la1[52] = jj_gen;
1557 break label_22;
1558 }
1559 jj_consume_token(LBRACKET);
1560 jj_consume_token(RBRACKET);
1561 _parameter.dimension++;
1562 }
1563 }
1564
1565 final public void Type() throws ParseException {
1566 switch (jj_nt.kind) {
1567 case BOOLEAN:
1568 case BYTE:
1569 case CHAR:
1570 case DOUBLE:
1571 case FLOAT:
1572 case INT:
1573 case LONG:
1574 case SHORT:
1575 PrimitiveType();
1576 break;
1577 case IDENTIFIER:
1578 Name();
1579 break;
1580 default:
1581 jj_la1[53] = jj_gen;
1582 jj_consume_token(-1);
1583 throw new ParseException();
1584 }
1585 label_23:
1586 while (true) {
1587 switch (jj_nt.kind) {
1588 case LBRACKET:
1589 ;
1590 break;
1591 default:
1592 jj_la1[54] = jj_gen;
1593 break label_23;
1594 }
1595 jj_consume_token(LBRACKET);
1596 jj_consume_token(RBRACKET);
1597 }
1598 }
1599
1600 final public Token PrimitiveType() throws ParseException {
1601 Token t = null;
1602 switch (jj_nt.kind) {
1603 case BOOLEAN:
1604 t = jj_consume_token(BOOLEAN);
1605 {if (true) return t;}
1606 break;
1607 case CHAR:
1608 t = jj_consume_token(CHAR);
1609 {if (true) return t;}
1610 break;
1611 case BYTE:
1612 t = jj_consume_token(BYTE);
1613 {if (true) return t;}
1614 break;
1615 case SHORT:
1616 t = jj_consume_token(SHORT);
1617 {if (true) return t;}
1618 break;
1619 case INT:
1620 t = jj_consume_token(INT);
1621 {if (true) return t;}
1622 break;
1623 case LONG:
1624 t = jj_consume_token(LONG);
1625 {if (true) return t;}
1626 break;
1627 case FLOAT:
1628 t = jj_consume_token(FLOAT);
1629 {if (true) return t;}
1630 break;
1631 case DOUBLE:
1632 t = jj_consume_token(DOUBLE);
1633 {if (true) return t;}
1634 break;
1635 default:
1636 jj_la1[55] = jj_gen;
1637 jj_consume_token(-1);
1638 throw new ParseException();
1639 }
1640 throw new Error("Missing return statement in function");
1641 }
1642
1643 final public void ResultType(MethodImpl methodImpl) throws ParseException {
1644 Token t = null;
1645 switch (jj_nt.kind) {
1646 case VOID:
1647 t = jj_consume_token(VOID);
1648 if( methodImpl != null ) {
1649 methodImpl.setReturnType( "void" );
1650 methodImpl.setReturnDimension( 0 );
1651 setToken( methodImpl, t );
1652 }
1653 break;
1654 case BOOLEAN:
1655 case BYTE:
1656 case CHAR:
1657 case DOUBLE:
1658 case FLOAT:
1659 case INT:
1660 case LONG:
1661 case SHORT:
1662 case IDENTIFIER:
1663 MethodResult_Type(methodImpl);
1664 break;
1665 default:
1666 jj_la1[56] = jj_gen;
1667 jj_consume_token(-1);
1668 throw new ParseException();
1669 }
1670 }
1671
1672 final public String Name() throws ParseException {
1673
1674 clearNameBuffer();
1675 Token t = null;
1676 _nameToken = jj_consume_token(IDENTIFIER);
1677 _nameBuffer.append(_nameToken.image);
1678 label_24:
1679 while (true) {
1680 if (jj_2_14(2)) {
1681 ;
1682 } else {
1683 break label_24;
1684 }
1685 jj_consume_token(DOT);
1686 t = jj_consume_token(IDENTIFIER);
1687 _nameBuffer.append(".").append(t.image);
1688 }
1689 {if (true) return _nameBuffer.toString();}
1690 throw new Error("Missing return statement in function");
1691 }
1692
1693 final public void ExecutableMemberThrows_Name(AbstractExecutableMember member) throws ParseException {
1694
1695 clearNameBuffer();
1696 Token t = null;
1697 t = jj_consume_token(IDENTIFIER);
1698 _nameBuffer.append(t.image);
1699 label_25:
1700 while (true) {
1701 switch (jj_nt.kind) {
1702 case DOT:
1703 ;
1704 break;
1705 default:
1706 jj_la1[57] = jj_gen;
1707 break label_25;
1708 }
1709 jj_consume_token(DOT);
1710 t = jj_consume_token(IDENTIFIER);
1711 _nameBuffer.append(".").append(t.image);
1712 }
1713 if( member != null ) {
1714 member.addThrownException( _nameBuffer.toString() );
1715 }
1716 }
1717
1718 final public void Interfaces_Name() throws ParseException {
1719 SourceClass sourceClass = currentClass();
1720
1721
1722 clearNameBuffer();
1723 Token t = null;
1724 t = jj_consume_token(IDENTIFIER);
1725 _nameBuffer.append(t.image);
1726 label_26:
1727 while (true) {
1728 switch (jj_nt.kind) {
1729 case DOT:
1730 ;
1731 break;
1732 default:
1733 jj_la1[58] = jj_gen;
1734 break label_26;
1735 }
1736 jj_consume_token(DOT);
1737 t = jj_consume_token(IDENTIFIER);
1738 _nameBuffer.append(".").append(t.image);
1739 }
1740 sourceClass.addInterface( _nameBuffer.toString() );
1741 }
1742
1743 final public void NameList() throws ParseException {
1744 Name();
1745 label_27:
1746 while (true) {
1747 switch (jj_nt.kind) {
1748 case COMMA:
1749 ;
1750 break;
1751 default:
1752 jj_la1[59] = jj_gen;
1753 break label_27;
1754 }
1755 jj_consume_token(COMMA);
1756 Name();
1757 }
1758 }
1759
1760 final public void ExecutableMemberThrows_NameList(AbstractExecutableMember member) throws ParseException {
1761 ExecutableMemberThrows_Name(member);
1762 label_28:
1763 while (true) {
1764 switch (jj_nt.kind) {
1765 case COMMA:
1766 ;
1767 break;
1768 default:
1769 jj_la1[60] = jj_gen;
1770 break label_28;
1771 }
1772 jj_consume_token(COMMA);
1773 ExecutableMemberThrows_Name(member);
1774 }
1775 }
1776
1777 final public void Interfaces_NameList() throws ParseException {
1778 Interfaces_Name();
1779 label_29:
1780 while (true) {
1781 switch (jj_nt.kind) {
1782 case COMMA:
1783 ;
1784 break;
1785 default:
1786 jj_la1[61] = jj_gen;
1787 break label_29;
1788 }
1789 jj_consume_token(COMMA);
1790 Interfaces_Name();
1791 }
1792 }
1793
1794
1795
1796
1797 final public void Expression() throws ParseException {
1798 ConditionalExpression();
1799 switch (jj_nt.kind) {
1800 case ASSIGN:
1801 case PLUSASSIGN:
1802 case MINUSASSIGN:
1803 case STARASSIGN:
1804 case SLASHASSIGN:
1805 case ANDASSIGN:
1806 case ORASSIGN:
1807 case XORASSIGN:
1808 case REMASSIGN:
1809 case LSHIFTASSIGN:
1810 case RSIGNEDSHIFTASSIGN:
1811 case RUNSIGNEDSHIFTASSIGN:
1812 AssignmentOperator();
1813 Expression();
1814 break;
1815 default:
1816 jj_la1[62] = jj_gen;
1817 ;
1818 }
1819 }
1820
1821 final public void AssignmentOperator() throws ParseException {
1822 switch (jj_nt.kind) {
1823 case ASSIGN:
1824 jj_consume_token(ASSIGN);
1825 break;
1826 case STARASSIGN:
1827 jj_consume_token(STARASSIGN);
1828 break;
1829 case SLASHASSIGN:
1830 jj_consume_token(SLASHASSIGN);
1831 break;
1832 case REMASSIGN:
1833 jj_consume_token(REMASSIGN);
1834 break;
1835 case PLUSASSIGN:
1836 jj_consume_token(PLUSASSIGN);
1837 break;
1838 case MINUSASSIGN:
1839 jj_consume_token(MINUSASSIGN);
1840 break;
1841 case LSHIFTASSIGN:
1842 jj_consume_token(LSHIFTASSIGN);
1843 break;
1844 case RSIGNEDSHIFTASSIGN:
1845 jj_consume_token(RSIGNEDSHIFTASSIGN);
1846 break;
1847 case RUNSIGNEDSHIFTASSIGN:
1848 jj_consume_token(RUNSIGNEDSHIFTASSIGN);
1849 break;
1850 case ANDASSIGN:
1851 jj_consume_token(ANDASSIGN);
1852 break;
1853 case XORASSIGN:
1854 jj_consume_token(XORASSIGN);
1855 break;
1856 case ORASSIGN:
1857 jj_consume_token(ORASSIGN);
1858 break;
1859 default:
1860 jj_la1[63] = jj_gen;
1861 jj_consume_token(-1);
1862 throw new ParseException();
1863 }
1864 }
1865
1866 final public void ConditionalExpression() throws ParseException {
1867 ConditionalOrExpression();
1868 switch (jj_nt.kind) {
1869 case HOOK:
1870 jj_consume_token(HOOK);
1871 Expression();
1872 jj_consume_token(COLON);
1873 ConditionalExpression();
1874 break;
1875 default:
1876 jj_la1[64] = jj_gen;
1877 ;
1878 }
1879 }
1880
1881 final public void ConditionalOrExpression() throws ParseException {
1882 ConditionalAndExpression();
1883 label_30:
1884 while (true) {
1885 switch (jj_nt.kind) {
1886 case SC_OR:
1887 ;
1888 break;
1889 default:
1890 jj_la1[65] = jj_gen;
1891 break label_30;
1892 }
1893 jj_consume_token(SC_OR);
1894 ConditionalAndExpression();
1895 }
1896 }
1897
1898 final public void ConditionalAndExpression() throws ParseException {
1899 InclusiveOrExpression();
1900 label_31:
1901 while (true) {
1902 switch (jj_nt.kind) {
1903 case SC_AND:
1904 ;
1905 break;
1906 default:
1907 jj_la1[66] = jj_gen;
1908 break label_31;
1909 }
1910 jj_consume_token(SC_AND);
1911 InclusiveOrExpression();
1912 }
1913 }
1914
1915 final public void InclusiveOrExpression() throws ParseException {
1916 ExclusiveOrExpression();
1917 label_32:
1918 while (true) {
1919 switch (jj_nt.kind) {
1920 case BIT_OR:
1921 ;
1922 break;
1923 default:
1924 jj_la1[67] = jj_gen;
1925 break label_32;
1926 }
1927 jj_consume_token(BIT_OR);
1928 ExclusiveOrExpression();
1929 }
1930 }
1931
1932 final public void ExclusiveOrExpression() throws ParseException {
1933 AndExpression();
1934 label_33:
1935 while (true) {
1936 switch (jj_nt.kind) {
1937 case XOR:
1938 ;
1939 break;
1940 default:
1941 jj_la1[68] = jj_gen;
1942 break label_33;
1943 }
1944 jj_consume_token(XOR);
1945 AndExpression();
1946 }
1947 }
1948
1949 final public void AndExpression() throws ParseException {
1950 EqualityExpression();
1951 label_34:
1952 while (true) {
1953 switch (jj_nt.kind) {
1954 case BIT_AND:
1955 ;
1956 break;
1957 default:
1958 jj_la1[69] = jj_gen;
1959 break label_34;
1960 }
1961 jj_consume_token(BIT_AND);
1962 EqualityExpression();
1963 }
1964 }
1965
1966 final public void EqualityExpression() throws ParseException {
1967 InstanceOfExpression();
1968 label_35:
1969 while (true) {
1970 switch (jj_nt.kind) {
1971 case EQ:
1972 case NE:
1973 ;
1974 break;
1975 default:
1976 jj_la1[70] = jj_gen;
1977 break label_35;
1978 }
1979 switch (jj_nt.kind) {
1980 case EQ:
1981 jj_consume_token(EQ);
1982 break;
1983 case NE:
1984 jj_consume_token(NE);
1985 break;
1986 default:
1987 jj_la1[71] = jj_gen;
1988 jj_consume_token(-1);
1989 throw new ParseException();
1990 }
1991 InstanceOfExpression();
1992 }
1993 }
1994
1995 final public void InstanceOfExpression() throws ParseException {
1996 RelationalExpression();
1997 switch (jj_nt.kind) {
1998 case INSTANCEOF:
1999 jj_consume_token(INSTANCEOF);
2000 Type();
2001 break;
2002 default:
2003 jj_la1[72] = jj_gen;
2004 ;
2005 }
2006 }
2007
2008 final public void RelationalExpression() throws ParseException {
2009 ShiftExpression();
2010 label_36:
2011 while (true) {
2012 switch (jj_nt.kind) {
2013 case GT:
2014 case LT:
2015 case LE:
2016 case GE:
2017 ;
2018 break;
2019 default:
2020 jj_la1[73] = jj_gen;
2021 break label_36;
2022 }
2023 switch (jj_nt.kind) {
2024 case LT:
2025 jj_consume_token(LT);
2026 break;
2027 case GT:
2028 jj_consume_token(GT);
2029 break;
2030 case LE:
2031 jj_consume_token(LE);
2032 break;
2033 case GE:
2034 jj_consume_token(GE);
2035 break;
2036 default:
2037 jj_la1[74] = jj_gen;
2038 jj_consume_token(-1);
2039 throw new ParseException();
2040 }
2041 ShiftExpression();
2042 }
2043 }
2044
2045 final public void ShiftExpression() throws ParseException {
2046 AdditiveExpression();
2047 label_37:
2048 while (true) {
2049 switch (jj_nt.kind) {
2050 case LSHIFT:
2051 case RSIGNEDSHIFT:
2052 case RUNSIGNEDSHIFT:
2053 ;
2054 break;
2055 default:
2056 jj_la1[75] = jj_gen;
2057 break label_37;
2058 }
2059 switch (jj_nt.kind) {
2060 case LSHIFT:
2061 jj_consume_token(LSHIFT);
2062 break;
2063 case RSIGNEDSHIFT:
2064 jj_consume_token(RSIGNEDSHIFT);
2065 break;
2066 case RUNSIGNEDSHIFT:
2067 jj_consume_token(RUNSIGNEDSHIFT);
2068 break;
2069 default:
2070 jj_la1[76] = jj_gen;
2071 jj_consume_token(-1);
2072 throw new ParseException();
2073 }
2074 AdditiveExpression();
2075 }
2076 }
2077
2078 final public void AdditiveExpression() throws ParseException {
2079 MultiplicativeExpression();
2080 label_38:
2081 while (true) {
2082 switch (jj_nt.kind) {
2083 case PLUS:
2084 case MINUS:
2085 ;
2086 break;
2087 default:
2088 jj_la1[77] = jj_gen;
2089 break label_38;
2090 }
2091 switch (jj_nt.kind) {
2092 case PLUS:
2093 jj_consume_token(PLUS);
2094 break;
2095 case MINUS:
2096 jj_consume_token(MINUS);
2097 break;
2098 default:
2099 jj_la1[78] = jj_gen;
2100 jj_consume_token(-1);
2101 throw new ParseException();
2102 }
2103 MultiplicativeExpression();
2104 }
2105 }
2106
2107 final public void MultiplicativeExpression() throws ParseException {
2108 UnaryExpression();
2109 label_39:
2110 while (true) {
2111 switch (jj_nt.kind) {
2112 case STAR:
2113 case SLASH:
2114 case REM:
2115 ;
2116 break;
2117 default:
2118 jj_la1[79] = jj_gen;
2119 break label_39;
2120 }
2121 switch (jj_nt.kind) {
2122 case STAR:
2123 jj_consume_token(STAR);
2124 break;
2125 case SLASH:
2126 jj_consume_token(SLASH);
2127 break;
2128 case REM:
2129 jj_consume_token(REM);
2130 break;
2131 default:
2132 jj_la1[80] = jj_gen;
2133 jj_consume_token(-1);
2134 throw new ParseException();
2135 }
2136 UnaryExpression();
2137 }
2138 }
2139
2140 final public void UnaryExpression() throws ParseException {
2141 switch (jj_nt.kind) {
2142 case PLUS:
2143 case MINUS:
2144 switch (jj_nt.kind) {
2145 case PLUS:
2146 jj_consume_token(PLUS);
2147 break;
2148 case MINUS:
2149 jj_consume_token(MINUS);
2150 break;
2151 default:
2152 jj_la1[81] = jj_gen;
2153 jj_consume_token(-1);
2154 throw new ParseException();
2155 }
2156 UnaryExpression();
2157 break;
2158 case INCR:
2159 PreIncrementExpression();
2160 break;
2161 case DECR:
2162 PreDecrementExpression();
2163 break;
2164 case BOOLEAN:
2165 case BYTE:
2166 case CHAR:
2167 case DOUBLE:
2168 case FALSE:
2169 case FLOAT:
2170 case INT:
2171 case LONG:
2172 case NEW:
2173 case NULL:
2174 case SHORT:
2175 case SUPER:
2176 case THIS:
2177 case TRUE:
2178 case VOID:
2179 case INTEGER_LITERAL:
2180 case FLOATING_POINT_LITERAL:
2181 case CHARACTER_LITERAL:
2182 case STRING_LITERAL:
2183 case IDENTIFIER:
2184 case LPAREN:
2185 case BANG:
2186 case TILDE:
2187 UnaryExpressionNotPlusMinus();
2188 break;
2189 default:
2190 jj_la1[82] = jj_gen;
2191 jj_consume_token(-1);
2192 throw new ParseException();
2193 }
2194 }
2195
2196 final public void PreIncrementExpression() throws ParseException {
2197 jj_consume_token(INCR);
2198 PrimaryExpression();
2199 }
2200
2201 final public void PreDecrementExpression() throws ParseException {
2202 jj_consume_token(DECR);
2203 PrimaryExpression();
2204 }
2205
2206 final public void UnaryExpressionNotPlusMinus() throws ParseException {
2207 switch (jj_nt.kind) {
2208 case BANG:
2209 case TILDE:
2210 switch (jj_nt.kind) {
2211 case TILDE:
2212 jj_consume_token(TILDE);
2213 break;
2214 case BANG:
2215 jj_consume_token(BANG);
2216 break;
2217 default:
2218 jj_la1[83] = jj_gen;
2219 jj_consume_token(-1);
2220 throw new ParseException();
2221 }
2222 UnaryExpression();
2223 break;
2224 default:
2225 jj_la1[84] = jj_gen;
2226 if (jj_2_15(2147483647)) {
2227 CastExpression();
2228 } else {
2229 switch (jj_nt.kind) {
2230 case BOOLEAN:
2231 case BYTE:
2232 case CHAR:
2233 case DOUBLE:
2234 case FALSE:
2235 case FLOAT:
2236 case INT:
2237 case LONG:
2238 case NEW:
2239 case NULL:
2240 case SHORT:
2241 case SUPER:
2242 case THIS:
2243 case TRUE:
2244 case VOID:
2245 case INTEGER_LITERAL:
2246 case FLOATING_POINT_LITERAL:
2247 case CHARACTER_LITERAL:
2248 case STRING_LITERAL:
2249 case IDENTIFIER:
2250 case LPAREN:
2251 PostfixExpression();
2252 break;
2253 default:
2254 jj_la1[85] = jj_gen;
2255 jj_consume_token(-1);
2256 throw new ParseException();
2257 }
2258 }
2259 }
2260 }
2261
2262
2263
2264
2265 final public void CastLookahead() throws ParseException {
2266 if (jj_2_16(2)) {
2267 jj_consume_token(LPAREN);
2268 PrimitiveType();
2269 } else if (jj_2_17(2147483647)) {
2270 jj_consume_token(LPAREN);
2271 Name();
2272 jj_consume_token(LBRACKET);
2273 jj_consume_token(RBRACKET);
2274 } else {
2275 switch (jj_nt.kind) {
2276 case LPAREN:
2277 jj_consume_token(LPAREN);
2278 Name();
2279 jj_consume_token(RPAREN);
2280 switch (jj_nt.kind) {
2281 case TILDE:
2282 jj_consume_token(TILDE);
2283 break;
2284 case BANG:
2285 jj_consume_token(BANG);
2286 break;
2287 case LPAREN:
2288 jj_consume_token(LPAREN);
2289 break;
2290 case IDENTIFIER:
2291 jj_consume_token(IDENTIFIER);
2292 break;
2293 case THIS:
2294 jj_consume_token(THIS);
2295 break;
2296 case SUPER:
2297 jj_consume_token(SUPER);
2298 break;
2299 case NEW:
2300 jj_consume_token(NEW);
2301 break;
2302 case FALSE:
2303 case NULL:
2304 case TRUE:
2305 case INTEGER_LITERAL:
2306 case FLOATING_POINT_LITERAL:
2307 case CHARACTER_LITERAL:
2308 case STRING_LITERAL:
2309 Literal();
2310 break;
2311 default:
2312 jj_la1[86] = jj_gen;
2313 jj_consume_token(-1);
2314 throw new ParseException();
2315 }
2316 break;
2317 default:
2318 jj_la1[87] = jj_gen;
2319 jj_consume_token(-1);
2320 throw new ParseException();
2321 }
2322 }
2323 }
2324
2325 final public void PostfixExpression() throws ParseException {
2326 PrimaryExpression();
2327 switch (jj_nt.kind) {
2328 case INCR:
2329 case DECR:
2330 switch (jj_nt.kind) {
2331 case INCR:
2332 jj_consume_token(INCR);
2333 break;
2334 case DECR:
2335 jj_consume_token(DECR);
2336 break;
2337 default:
2338 jj_la1[88] = jj_gen;
2339 jj_consume_token(-1);
2340 throw new ParseException();
2341 }
2342 break;
2343 default:
2344 jj_la1[89] = jj_gen;
2345 ;
2346 }
2347 }
2348
2349 final public void CastExpression() throws ParseException {
2350 if (jj_2_18(2147483647)) {
2351 jj_consume_token(LPAREN);
2352 Type();
2353 jj_consume_token(RPAREN);
2354 UnaryExpression();
2355 } else {
2356 switch (jj_nt.kind) {
2357 case LPAREN:
2358 jj_consume_token(LPAREN);
2359 Type();
2360 jj_consume_token(RPAREN);
2361 UnaryExpressionNotPlusMinus();
2362 break;
2363 default:
2364 jj_la1[90] = jj_gen;
2365 jj_consume_token(-1);
2366 throw new ParseException();
2367 }
2368 }
2369 }
2370
2371 final public void PrimaryExpression() throws ParseException {
2372 PrimaryPrefix();
2373 label_40:
2374 while (true) {
2375 if (jj_2_19(2)) {
2376 ;
2377 } else {
2378 break label_40;
2379 }
2380 PrimarySuffix();
2381 }
2382 }
2383
2384 final public void PrimaryPrefix() throws ParseException {
2385 switch (jj_nt.kind) {
2386 case FALSE:
2387 case NULL:
2388 case TRUE:
2389 case INTEGER_LITERAL:
2390 case FLOATING_POINT_LITERAL:
2391 case CHARACTER_LITERAL:
2392 case STRING_LITERAL:
2393 Literal();
2394 break;
2395 case THIS:
2396 jj_consume_token(THIS);
2397 break;
2398 case SUPER:
2399 jj_consume_token(SUPER);
2400 jj_consume_token(DOT);
2401 jj_consume_token(IDENTIFIER);
2402 break;
2403 case LPAREN:
2404 jj_consume_token(LPAREN);
2405 Expression();
2406 jj_consume_token(RPAREN);
2407 break;
2408 case NEW:
2409 AllocationExpression();
2410 break;
2411 default:
2412 jj_la1[91] = jj_gen;
2413 if (jj_2_20(2147483647)) {
2414 ResultType(null);
2415 jj_consume_token(DOT);
2416 jj_consume_token(CLASS);
2417 } else {
2418 switch (jj_nt.kind) {
2419 case IDENTIFIER:
2420 Name();
2421 break;
2422 default:
2423 jj_la1[92] = jj_gen;
2424 jj_consume_token(-1);
2425 throw new ParseException();
2426 }
2427 }
2428 }
2429 }
2430
2431 final public void PrimarySuffix() throws ParseException {
2432 if (jj_2_21(2)) {
2433 jj_consume_token(DOT);
2434 jj_consume_token(THIS);
2435 } else if (jj_2_22(2)) {
2436 jj_consume_token(DOT);
2437 jj_consume_token(SUPER);
2438 } else if (jj_2_23(2)) {
2439 jj_consume_token(DOT);
2440 AllocationExpression();
2441 } else {
2442 switch (jj_nt.kind) {
2443 case LBRACKET:
2444 jj_consume_token(LBRACKET);
2445 Expression();
2446 jj_consume_token(RBRACKET);
2447 break;
2448 case DOT:
2449 jj_consume_token(DOT);
2450 jj_consume_token(IDENTIFIER);
2451 break;
2452 case LPAREN:
2453 Arguments();
2454 break;
2455 default:
2456 jj_la1[93] = jj_gen;
2457 jj_consume_token(-1);
2458 throw new ParseException();
2459 }
2460 }
2461 }
2462
2463 final public void Literal() throws ParseException {
2464 switch (jj_nt.kind) {
2465 case INTEGER_LITERAL:
2466 jj_consume_token(INTEGER_LITERAL);
2467 break;
2468 case FLOATING_POINT_LITERAL:
2469 jj_consume_token(FLOATING_POINT_LITERAL);
2470 break;
2471 case CHARACTER_LITERAL:
2472 jj_consume_token(CHARACTER_LITERAL);
2473 break;
2474 case STRING_LITERAL:
2475 jj_consume_token(STRING_LITERAL);
2476 break;
2477 case FALSE:
2478 case TRUE:
2479 BooleanLiteral();
2480 break;
2481 case NULL:
2482 NullLiteral();
2483 break;
2484 default:
2485 jj_la1[94] = jj_gen;
2486 jj_consume_token(-1);
2487 throw new ParseException();
2488 }
2489 }
2490
2491 final public void BooleanLiteral() throws ParseException {
2492 switch (jj_nt.kind) {
2493 case TRUE:
2494 jj_consume_token(TRUE);
2495 break;
2496 case FALSE:
2497 jj_consume_token(FALSE);
2498 break;
2499 default:
2500 jj_la1[95] = jj_gen;
2501 jj_consume_token(-1);
2502 throw new ParseException();
2503 }
2504 }
2505
2506 final public void NullLiteral() throws ParseException {
2507 jj_consume_token(NULL);
2508 }
2509
2510 final public void Arguments() throws ParseException {
2511 jj_consume_token(LPAREN);
2512 switch (jj_nt.kind) {
2513 case BOOLEAN:
2514 case BYTE:
2515 case CHAR:
2516 case DOUBLE:
2517 case FALSE:
2518 case FLOAT:
2519 case INT:
2520 case LONG:
2521 case NEW:
2522 case NULL:
2523 case SHORT:
2524 case SUPER:
2525 case THIS:
2526 case TRUE:
2527 case VOID:
2528 case INTEGER_LITERAL:
2529 case FLOATING_POINT_LITERAL:
2530 case CHARACTER_LITERAL:
2531 case STRING_LITERAL:
2532 case IDENTIFIER:
2533 case LPAREN:
2534 case BANG:
2535 case TILDE:
2536 case INCR:
2537 case DECR:
2538 case PLUS:
2539 case MINUS:
2540 ArgumentList();
2541 break;
2542 default:
2543 jj_la1[96] = jj_gen;
2544 ;
2545 }
2546 jj_consume_token(RPAREN);
2547 }
2548
2549 final public void ArgumentList() throws ParseException {
2550 Expression();
2551 label_41:
2552 while (true) {
2553 switch (jj_nt.kind) {
2554 case COMMA:
2555 ;
2556 break;
2557 default:
2558 jj_la1[97] = jj_gen;
2559 break label_41;
2560 }
2561 jj_consume_token(COMMA);
2562 Expression();
2563 }
2564 }
2565
2566 /***
2567 * @todo Anonymous classes will cause NPE. Need to check for nullity in a lot of places
2568 */
2569 final public void AllocationExpression() throws ParseException {
2570 String realisedClass;
2571 if (jj_2_24(2)) {
2572 jj_consume_token(NEW);
2573 PrimitiveType();
2574 ArrayDimsAndInits();
2575 } else {
2576 switch (jj_nt.kind) {
2577 case NEW:
2578 jj_consume_token(NEW);
2579 realisedClass = Name();
2580 switch (jj_nt.kind) {
2581 case LBRACKET:
2582 ArrayDimsAndInits();
2583 break;
2584 case LPAREN:
2585 Arguments();
2586 switch (jj_nt.kind) {
2587 case LBRACE:
2588
2589 SourceClass containingClass = currentClass();
2590 pushAndGet();
2591 ClassBody();
2592
2593
2594 currentClass().setName(containingClass.getNextAnonymousClassName());
2595 currentClass().setRealised(realisedClass);
2596 popAndAddInner();
2597 break;
2598 default:
2599 jj_la1[98] = jj_gen;
2600 ;
2601 }
2602 break;
2603 default:
2604 jj_la1[99] = jj_gen;
2605 jj_consume_token(-1);
2606 throw new ParseException();
2607 }
2608 break;
2609 default:
2610 jj_la1[100] = jj_gen;
2611 jj_consume_token(-1);
2612 throw new ParseException();
2613 }
2614 }
2615 }
2616
2617
2618
2619
2620
2621 final public void ArrayDimsAndInits() throws ParseException {
2622 if (jj_2_27(2)) {
2623 label_42:
2624 while (true) {
2625 jj_consume_token(LBRACKET);
2626 Expression();
2627 jj_consume_token(RBRACKET);
2628 if (jj_2_25(2)) {
2629 ;
2630 } else {
2631 break label_42;
2632 }
2633 }
2634 label_43:
2635 while (true) {
2636 if (jj_2_26(2)) {
2637 ;
2638 } else {
2639 break label_43;
2640 }
2641 jj_consume_token(LBRACKET);
2642 jj_consume_token(RBRACKET);
2643 }
2644 } else {
2645 switch (jj_nt.kind) {
2646 case LBRACKET:
2647 label_44:
2648 while (true) {
2649 jj_consume_token(LBRACKET);
2650 jj_consume_token(RBRACKET);
2651 switch (jj_nt.kind) {
2652 case LBRACKET:
2653 ;
2654 break;
2655 default:
2656 jj_la1[101] = jj_gen;
2657 break label_44;
2658 }
2659 }
2660 ArrayInitializer();
2661 break;
2662 default:
2663 jj_la1[102] = jj_gen;
2664 jj_consume_token(-1);
2665 throw new ParseException();
2666 }
2667 }
2668 }
2669
2670
2671
2672
2673 final public void Statement() throws ParseException {
2674 if (jj_2_28(2)) {
2675 LabeledStatement();
2676 } else {
2677 switch (jj_nt.kind) {
2678 case LBRACE:
2679 Block();
2680 break;
2681 case SEMICOLON:
2682 EmptyStatement();
2683 break;
2684 case BOOLEAN:
2685 case BYTE:
2686 case CHAR:
2687 case DOUBLE:
2688 case FALSE:
2689 case FLOAT:
2690 case INT:
2691 case LONG:
2692 case NEW:
2693 case NULL:
2694 case SHORT:
2695 case SUPER:
2696 case THIS:
2697 case TRUE:
2698 case VOID:
2699 case INTEGER_LITERAL:
2700 case FLOATING_POINT_LITERAL:
2701 case CHARACTER_LITERAL:
2702 case STRING_LITERAL:
2703 case IDENTIFIER:
2704 case LPAREN:
2705 case INCR:
2706 case DECR:
2707 StatementExpression();
2708 jj_consume_token(SEMICOLON);
2709 break;
2710 case SWITCH:
2711 SwitchStatement();
2712 break;
2713 case IF:
2714 IfStatement();
2715 break;
2716 case WHILE:
2717 WhileStatement();
2718 break;
2719 case DO:
2720 DoStatement();
2721 break;
2722 case FOR:
2723 ForStatement();
2724 break;
2725 case BREAK:
2726 BreakStatement();
2727 break;
2728 case CONTINUE:
2729 ContinueStatement();
2730 break;
2731 case RETURN:
2732 ReturnStatement();
2733 break;
2734 case THROW:
2735 ThrowStatement();
2736 break;
2737 case SYNCHRONIZED:
2738 SynchronizedStatement();
2739 break;
2740 case TRY:
2741 TryStatement();
2742 break;
2743 case ASSERT:
2744 AssertStatement();
2745 break;
2746 default:
2747 jj_la1[103] = jj_gen;
2748 jj_consume_token(-1);
2749 throw new ParseException();
2750 }
2751 }
2752 }
2753
2754 final public void LabeledStatement() throws ParseException {
2755 jj_consume_token(IDENTIFIER);
2756 jj_consume_token(COLON);
2757 Statement();
2758 }
2759
2760 final public void Block() throws ParseException {
2761 jj_consume_token(LBRACE);
2762 label_45:
2763 while (true) {
2764 switch (jj_nt.kind) {
2765 case BOOLEAN:
2766 case BREAK:
2767 case BYTE:
2768 case CHAR:
2769 case CLASS:
2770 case CONTINUE:
2771 case DO:
2772 case DOUBLE:
2773 case FALSE:
2774 case FINAL:
2775 case FLOAT:
2776 case FOR:
2777 case IF:
2778 case INT:
2779 case INTERFACE:
2780 case LONG:
2781 case NEW:
2782 case NULL:
2783 case RETURN:
2784 case SHORT:
2785 case SUPER:
2786 case SWITCH:
2787 case SYNCHRONIZED:
2788 case THIS:
2789 case THROW:
2790 case TRUE:
2791 case TRY:
2792 case VOID:
2793 case WHILE:
2794 case ASSERT:
2795 case INTEGER_LITERAL:
2796 case FLOATING_POINT_LITERAL:
2797 case CHARACTER_LITERAL:
2798 case STRING_LITERAL:
2799 case IDENTIFIER:
2800 case LPAREN:
2801 case LBRACE:
2802 case SEMICOLON:
2803 case INCR:
2804 case DECR:
2805 ;
2806 break;
2807 default:
2808 jj_la1[104] = jj_gen;
2809 break label_45;
2810 }
2811 BlockStatement();
2812 }
2813 jj_consume_token(RBRACE);
2814 }
2815
2816 final public void Method_Block() throws ParseException {
2817 jj_consume_token(LBRACE);
2818 label_46:
2819 while (true) {
2820 switch (jj_nt.kind) {
2821 case BOOLEAN:
2822 case BREAK:
2823 case BYTE:
2824 case CHAR:
2825 case CLASS:
2826 case CONTINUE:
2827 case DO:
2828 case DOUBLE:
2829 case FALSE:
2830 case FINAL:
2831 case FLOAT:
2832 case FOR:
2833 case IF:
2834 case INT:
2835 case INTERFACE:
2836 case LONG:
2837 case NEW:
2838 case NULL:
2839 case RETURN:
2840 case SHORT:
2841 case SUPER:
2842 case SWITCH:
2843 case SYNCHRONIZED:
2844 case THIS:
2845 case THROW:
2846 case TRUE:
2847 case TRY:
2848 case VOID:
2849 case WHILE:
2850 case ASSERT:
2851 case INTEGER_LITERAL:
2852 case FLOATING_POINT_LITERAL:
2853 case CHARACTER_LITERAL:
2854 case STRING_LITERAL:
2855 case IDENTIFIER:
2856 case LPAREN:
2857 case LBRACE:
2858 case SEMICOLON:
2859 case INCR:
2860 case DECR:
2861 ;
2862 break;
2863 default:
2864 jj_la1[105] = jj_gen;
2865 break label_46;
2866 }
2867 Method_BlockStatement();
2868 }
2869 jj_consume_token(RBRACE);
2870 switch (jj_nt.kind) {
2871 case SEMICOLON:
2872 jj_consume_token(SEMICOLON);
2873 break;
2874 default:
2875 jj_la1[106] = jj_gen;
2876 ;
2877 }
2878 }
2879
2880 /***
2881 * @todo not sure if the UnmodifiedClassDeclaration/UnmodifiedInterfaceDeclaration
2882 * ever get called, now that we have two different blocks. It would be nice to remove them
2883 */
2884 final public void BlockStatement() throws ParseException {
2885 if (jj_2_29(2147483647)) {
2886 LocalVariableDeclaration();
2887 jj_consume_token(SEMICOLON);
2888 } else {
2889 switch (jj_nt.kind) {
2890 case BOOLEAN:
2891 case BREAK:
2892 case BYTE:
2893 case CHAR:
2894 case CONTINUE:
2895 case DO:
2896 case DOUBLE:
2897 case FALSE:
2898 case FLOAT:
2899 case FOR:
2900 case IF:
2901 case INT:
2902 case LONG:
2903 case NEW:
2904 case NULL:
2905 case RETURN:
2906 case SHORT:
2907 case SUPER:
2908 case SWITCH:
2909 case SYNCHRONIZED:
2910 case THIS:
2911 case THROW:
2912 case TRUE:
2913 case TRY:
2914 case VOID:
2915 case WHILE:
2916 case ASSERT:
2917 case INTEGER_LITERAL:
2918 case FLOATING_POINT_LITERAL:
2919 case CHARACTER_LITERAL:
2920 case STRING_LITERAL:
2921 case IDENTIFIER:
2922 case LPAREN:
2923 case LBRACE:
2924 case SEMICOLON:
2925 case INCR:
2926 case DECR:
2927 Statement();
2928 break;
2929 case CLASS:
2930 pushAndGet();
2931 UnmodifiedClassDeclaration();
2932 popAndAddInner();
2933 break;
2934 case INTERFACE:
2935 pushAndGet();
2936 UnmodifiedInterfaceDeclaration();
2937 popAndAddInner();
2938 break;
2939 default:
2940 jj_la1[107] = jj_gen;
2941 jj_consume_token(-1);
2942 throw new ParseException();
2943 }
2944 }
2945 }
2946
2947 final public void Method_BlockStatement() throws ParseException {
2948 if (jj_2_30(2147483647)) {
2949 LocalVariableDeclaration();
2950 jj_consume_token(SEMICOLON);
2951 } else {
2952 switch (jj_nt.kind) {
2953 case BOOLEAN:
2954 case BREAK:
2955 case BYTE:
2956 case CHAR:
2957 case CONTINUE:
2958 case DO:
2959 case DOUBLE:
2960 case FALSE:
2961 case FLOAT:
2962 case FOR:
2963 case IF:
2964 case INT:
2965 case LONG:
2966 case NEW:
2967 case NULL:
2968 case RETURN:
2969 case SHORT:
2970 case SUPER:
2971 case SWITCH:
2972 case SYNCHRONIZED:
2973 case THIS:
2974 case THROW:
2975 case TRUE:
2976 case TRY:
2977 case VOID:
2978 case WHILE:
2979 case ASSERT:
2980 case INTEGER_LITERAL:
2981 case FLOATING_POINT_LITERAL:
2982 case CHARACTER_LITERAL:
2983 case STRING_LITERAL:
2984 case IDENTIFIER:
2985 case LPAREN:
2986 case LBRACE:
2987 case SEMICOLON:
2988 case INCR:
2989 case DECR:
2990 Statement();
2991 break;
2992 case CLASS:
2993 pushAndGet();
2994 UnmodifiedClassDeclaration();
2995 popAndAddInner();
2996 break;
2997 case INTERFACE:
2998 pushAndGet();
2999 UnmodifiedInterfaceDeclaration();
3000 popAndAddInner();
3001 break;
3002 default:
3003 jj_la1[108] = jj_gen;
3004 jj_consume_token(-1);
3005 throw new ParseException();
3006 }
3007 }
3008 }
3009
3010 final public void LocalVariableDeclaration() throws ParseException {
3011 switch (jj_nt.kind) {
3012 case FINAL:
3013 jj_consume_token(FINAL);
3014 break;
3015 default:
3016 jj_la1[109] = jj_gen;
3017 ;
3018 }
3019 Type();
3020 VariableDeclarator();
3021 label_47:
3022 while (true) {
3023 switch (jj_nt.kind) {
3024 case COMMA:
3025 ;
3026 break;
3027 default:
3028 jj_la1[110] = jj_gen;
3029 break label_47;
3030 }
3031 jj_consume_token(COMMA);
3032 VariableDeclarator();
3033 }
3034 }
3035
3036 final public void EmptyStatement() throws ParseException {
3037 jj_consume_token(SEMICOLON);
3038 }
3039
3040 final public void StatementExpression() throws ParseException {
3041 switch (jj_nt.kind) {
3042 case INCR:
3043 PreIncrementExpression();
3044 break;
3045 case DECR:
3046 PreDecrementExpression();
3047 break;
3048 case BOOLEAN:
3049 case BYTE:
3050 case CHAR:
3051 case DOUBLE:
3052 case FALSE:
3053 case FLOAT:
3054 case INT:
3055 case LONG:
3056 case NEW:
3057 case NULL:
3058 case SHORT:
3059 case SUPER:
3060 case THIS:
3061 case TRUE:
3062 case VOID:
3063 case INTEGER_LITERAL:
3064 case FLOATING_POINT_LITERAL:
3065 case CHARACTER_LITERAL:
3066 case STRING_LITERAL:
3067 case IDENTIFIER:
3068 case LPAREN:
3069 PrimaryExpression();
3070 switch (jj_nt.kind) {
3071 case ASSIGN:
3072 case INCR:
3073 case DECR:
3074 case PLUSASSIGN:
3075 case MINUSASSIGN:
3076 case STARASSIGN:
3077 case SLASHASSIGN:
3078 case ANDASSIGN:
3079 case ORASSIGN:
3080 case XORASSIGN:
3081 case REMASSIGN:
3082 case LSHIFTASSIGN:
3083 case RSIGNEDSHIFTASSIGN:
3084 case RUNSIGNEDSHIFTASSIGN:
3085 switch (jj_nt.kind) {
3086 case INCR:
3087 jj_consume_token(INCR);
3088 break;
3089 case DECR:
3090 jj_consume_token(DECR);
3091 break;
3092 case ASSIGN:
3093 case PLUSASSIGN:
3094 case MINUSASSIGN:
3095 case STARASSIGN:
3096 case SLASHASSIGN:
3097 case ANDASSIGN:
3098 case ORASSIGN:
3099 case XORASSIGN:
3100 case REMASSIGN:
3101 case LSHIFTASSIGN:
3102 case RSIGNEDSHIFTASSIGN:
3103 case RUNSIGNEDSHIFTASSIGN:
3104 AssignmentOperator();
3105 Expression();
3106 break;
3107 default:
3108 jj_la1[111] = jj_gen;
3109 jj_consume_token(-1);
3110 throw new ParseException();
3111 }
3112 break;
3113 default:
3114 jj_la1[112] = jj_gen;
3115 ;
3116 }
3117 break;
3118 default:
3119 jj_la1[113] = jj_gen;
3120 jj_consume_token(-1);
3121 throw new ParseException();
3122 }
3123 }
3124
3125 final public void SwitchStatement() throws ParseException {
3126 jj_consume_token(SWITCH);
3127 jj_consume_token(LPAREN);
3128 Expression();
3129 jj_consume_token(RPAREN);
3130 jj_consume_token(LBRACE);
3131 label_48:
3132 while (true) {
3133 switch (jj_nt.kind) {
3134 case CASE:
3135 case _DEFAULT:
3136 ;
3137 break;
3138 default:
3139 jj_la1[114] = jj_gen;
3140 break label_48;
3141 }
3142 SwitchLabel();
3143 label_49:
3144 while (true) {
3145 switch (jj_nt.kind) {
3146 case BOOLEAN:
3147 case BREAK:
3148 case BYTE:
3149 case CHAR:
3150 case CLASS:
3151 case CONTINUE:
3152 case DO:
3153 case DOUBLE:
3154 case FALSE:
3155 case FINAL:
3156 case FLOAT:
3157 case FOR:
3158 case IF:
3159 case INT:
3160 case INTERFACE:
3161 case LONG:
3162 case NEW:
3163 case NULL:
3164 case RETURN:
3165 case SHORT:
3166 case SUPER:
3167 case SWITCH:
3168 case SYNCHRONIZED:
3169 case THIS:
3170 case THROW:
3171 case TRUE:
3172 case TRY:
3173 case VOID:
3174 case WHILE:
3175 case ASSERT:
3176 case INTEGER_LITERAL:
3177 case FLOATING_POINT_LITERAL:
3178 case CHARACTER_LITERAL:
3179 case STRING_LITERAL:
3180 case IDENTIFIER:
3181 case LPAREN:
3182 case LBRACE:
3183 case SEMICOLON:
3184 case INCR:
3185 case DECR:
3186 ;
3187 break;
3188 default:
3189 jj_la1[115] = jj_gen;
3190 break label_49;
3191 }
3192 BlockStatement();
3193 }
3194 }
3195 jj_consume_token(RBRACE);
3196 }
3197
3198 final public void SwitchLabel() throws ParseException {
3199 switch (jj_nt.kind) {
3200 case CASE:
3201 jj_consume_token(CASE);
3202 Expression();
3203 jj_consume_token(COLON);
3204 break;
3205 case _DEFAULT:
3206 jj_consume_token(_DEFAULT);
3207 jj_consume_token(COLON);
3208 break;
3209 default:
3210 jj_la1[116] = jj_gen;
3211 jj_consume_token(-1);
3212 throw new ParseException();
3213 }
3214 }
3215
3216 final public void IfStatement() throws ParseException {
3217 jj_consume_token(IF);
3218 jj_consume_token(LPAREN);
3219 Expression();
3220 jj_consume_token(RPAREN);
3221 Statement();
3222 switch (jj_nt.kind) {
3223 case ELSE:
3224 jj_consume_token(ELSE);
3225 Statement();
3226 break;
3227 default:
3228 jj_la1[117] = jj_gen;
3229 ;
3230 }
3231 }
3232
3233 final public void WhileStatement() throws ParseException {
3234 jj_consume_token(WHILE);
3235 jj_consume_token(LPAREN);
3236 Expression();
3237 jj_consume_token(RPAREN);
3238 Statement();
3239 }
3240
3241 final public void DoStatement() throws ParseException {
3242 jj_consume_token(DO);
3243 Statement();
3244 jj_consume_token(WHILE);
3245 jj_consume_token(LPAREN);
3246 Expression();
3247 jj_consume_token(RPAREN);
3248 jj_consume_token(SEMICOLON);
3249 }
3250
3251 final public void ForStatement() throws ParseException {
3252 jj_consume_token(FOR);
3253 jj_consume_token(LPAREN);
3254 switch (jj_nt.kind) {
3255 case BOOLEAN:
3256 case BYTE:
3257 case CHAR:
3258 case DOUBLE:
3259 case FALSE:
3260 case FINAL:
3261 case FLOAT:
3262 case INT:
3263 case LONG:
3264 case NEW:
3265 case NULL:
3266 case SHORT:
3267 case SUPER:
3268 case THIS:
3269 case TRUE:
3270 case VOID:
3271 case INTEGER_LITERAL:
3272 case FLOATING_POINT_LITERAL:
3273 case CHARACTER_LITERAL:
3274 case STRING_LITERAL:
3275 case IDENTIFIER:
3276 case LPAREN:
3277 case INCR:
3278 case DECR:
3279 ForInit();
3280 break;
3281 default:
3282 jj_la1[118] = jj_gen;
3283 ;
3284 }
3285 jj_consume_token(SEMICOLON);
3286 switch (jj_nt.kind) {
3287 case BOOLEAN:
3288 case BYTE:
3289 case CHAR:
3290 case DOUBLE:
3291 case FALSE:
3292 case FLOAT:
3293 case INT:
3294 case LONG:
3295 case NEW:
3296 case NULL:
3297 case SHORT:
3298 case SUPER:
3299 case THIS:
3300 case TRUE:
3301 case VOID:
3302 case INTEGER_LITERAL:
3303 case FLOATING_POINT_LITERAL:
3304 case CHARACTER_LITERAL:
3305 case STRING_LITERAL:
3306 case IDENTIFIER:
3307 case LPAREN:
3308 case BANG:
3309 case TILDE:
3310 case INCR:
3311 case DECR:
3312 case PLUS:
3313 case MINUS:
3314 Expression();
3315 break;
3316 default:
3317 jj_la1[119] = jj_gen;
3318 ;
3319 }
3320 jj_consume_token(SEMICOLON);
3321 switch (jj_nt.kind) {
3322 case BOOLEAN:
3323 case BYTE:
3324 case CHAR:
3325 case DOUBLE:
3326 case FALSE:
3327 case FLOAT:
3328 case INT:
3329 case LONG:
3330 case NEW:
3331 case NULL:
3332 case SHORT:
3333 case SUPER:
3334 case THIS:
3335 case TRUE:
3336 case VOID:
3337 case INTEGER_LITERAL:
3338 case FLOATING_POINT_LITERAL:
3339 case CHARACTER_LITERAL:
3340 case STRING_LITERAL:
3341 case IDENTIFIER:
3342 case LPAREN:
3343 case INCR:
3344 case DECR:
3345 ForUpdate();
3346 break;
3347 default:
3348 jj_la1[120] = jj_gen;
3349 ;
3350 }
3351 jj_consume_token(RPAREN);
3352 Statement();
3353 }
3354
3355 final public void ForInit() throws ParseException {
3356 if (jj_2_31(2147483647)) {
3357 LocalVariableDeclaration();
3358 } else {
3359 switch (jj_nt.kind) {
3360 case BOOLEAN:
3361 case BYTE:
3362 case CHAR:
3363 case DOUBLE:
3364 case FALSE:
3365 case FLOAT:
3366 case INT:
3367 case LONG:
3368 case NEW:
3369 case NULL:
3370 case SHORT:
3371 case SUPER:
3372 case THIS:
3373 case TRUE:
3374 case VOID:
3375 case INTEGER_LITERAL:
3376 case FLOATING_POINT_LITERAL:
3377 case CHARACTER_LITERAL:
3378 case STRING_LITERAL:
3379 case IDENTIFIER:
3380 case LPAREN:
3381 case INCR:
3382 case DECR:
3383 StatementExpressionList();
3384 break;
3385 default:
3386 jj_la1[121] = jj_gen;
3387 jj_consume_token(-1);
3388 throw new ParseException();
3389 }
3390 }
3391 }
3392
3393 final public void StatementExpressionList() throws ParseException {
3394 StatementExpression();
3395 label_50:
3396 while (true) {
3397 switch (jj_nt.kind) {
3398 case COMMA:
3399 ;
3400 break;
3401 default:
3402 jj_la1[122] = jj_gen;
3403 break label_50;
3404 }
3405 jj_consume_token(COMMA);
3406 StatementExpression();
3407 }
3408 }
3409
3410 final public void ForUpdate() throws ParseException {
3411 StatementExpressionList();
3412 }
3413
3414 final public void BreakStatement() throws ParseException {
3415 jj_consume_token(BREAK);
3416 switch (jj_nt.kind) {
3417 case IDENTIFIER:
3418 jj_consume_token(IDENTIFIER);
3419 break;
3420 default:
3421 jj_la1[123] = jj_gen;
3422 ;
3423 }
3424 jj_consume_token(SEMICOLON);
3425 }
3426
3427 final public void ContinueStatement() throws ParseException {
3428 jj_consume_token(CONTINUE);
3429 switch (jj_nt.kind) {
3430 case IDENTIFIER:
3431 jj_consume_token(IDENTIFIER);
3432 break;
3433 default:
3434 jj_la1[124] = jj_gen;
3435 ;
3436 }
3437 jj_consume_token(SEMICOLON);
3438 }
3439
3440 final public void ReturnStatement() throws ParseException {
3441 jj_consume_token(RETURN);
3442 switch (jj_nt.kind) {
3443 case BOOLEAN:
3444 case BYTE:
3445 case CHAR:
3446 case DOUBLE:
3447 case FALSE:
3448 case FLOAT:
3449 case INT:
3450 case LONG:
3451 case NEW:
3452 case NULL:
3453 case SHORT:
3454 case SUPER:
3455 case THIS:
3456 case TRUE:
3457 case VOID:
3458 case INTEGER_LITERAL:
3459 case FLOATING_POINT_LITERAL:
3460 case CHARACTER_LITERAL:
3461 case STRING_LITERAL:
3462 case IDENTIFIER:
3463 case LPAREN:
3464 case BANG:
3465 case TILDE:
3466 case INCR:
3467 case DECR:
3468 case PLUS:
3469 case MINUS:
3470 Expression();
3471 break;
3472 default:
3473 jj_la1[125] = jj_gen;
3474 ;
3475 }
3476 jj_consume_token(SEMICOLON);
3477 }
3478
3479 final public void ThrowStatement() throws ParseException {
3480 jj_consume_token(THROW);
3481 Expression();
3482 jj_consume_token(SEMICOLON);
3483 }
3484
3485 final public void SynchronizedStatement() throws ParseException {
3486 jj_consume_token(SYNCHRONIZED);
3487 jj_consume_token(LPAREN);
3488 Expression();
3489 jj_consume_token(RPAREN);
3490 Block();
3491 }
3492
3493 final public void TryStatement() throws ParseException {
3494 jj_consume_token(TRY);
3495 Block();
3496 label_51:
3497 while (true) {
3498 switch (jj_nt.kind) {
3499 case CATCH:
3500 ;
3501 break;
3502 default:
3503 jj_la1[126] = jj_gen;
3504 break label_51;
3505 }
3506 jj_consume_token(CATCH);
3507 jj_consume_token(LPAREN);
3508 FormalParameter(null);
3509 jj_consume_token(RPAREN);
3510 Block();
3511 }
3512 switch (jj_nt.kind) {
3513 case FINALLY:
3514 jj_consume_token(FINALLY);
3515 Block();
3516 break;
3517 default:
3518 jj_la1[127] = jj_gen;
3519 ;
3520 }
3521 }
3522
3523 final public void AssertStatement() throws ParseException {
3524 jj_consume_token(ASSERT);
3525 Expression();
3526 switch (jj_nt.kind) {
3527 case COLON:
3528 jj_consume_token(COLON);
3529 Expression();
3530 break;
3531 default:
3532 jj_la1[128] = jj_gen;
3533 ;
3534 }
3535 jj_consume_token(SEMICOLON);
3536 }
3537
3538 final private boolean jj_2_1(int xla) {
3539 jj_la = xla; jj_lastpos = jj_scanpos = token;
3540 boolean retval = !jj_3_1();
3541 jj_save(0, xla);
3542 return retval;
3543 }
3544
3545 final private boolean jj_2_2(int xla) {
3546 jj_la = xla; jj_lastpos = jj_scanpos = token;
3547 boolean retval = !jj_3_2();
3548 jj_save(1, xla);
3549 return retval;
3550 }
3551
3552 final private boolean jj_2_3(int xla) {
3553 jj_la = xla; jj_lastpos = jj_scanpos = token;
3554 boolean retval = !jj_3_3();
3555 jj_save(2, xla);
3556 return retval;
3557 }
3558
3559 final private boolean jj_2_4(int xla) {
3560 jj_la = xla; jj_lastpos = jj_scanpos = token;
3561 boolean retval = !jj_3_4();
3562 jj_save(3, xla);
3563 return retval;
3564 }
3565
3566 final private boolean jj_2_5(int xla) {
3567 jj_la = xla; jj_lastpos = jj_scanpos = token;
3568 boolean retval = !jj_3_5();
3569 jj_save(4, xla);
3570 return retval;
3571 }
3572
3573 final private boolean jj_2_6(int xla) {
3574 jj_la = xla; jj_lastpos = jj_scanpos = token;
3575 boolean retval = !jj_3_6();
3576 jj_save(5, xla);
3577 return retval;
3578 }
3579
3580 final private boolean jj_2_7(int xla) {
3581 jj_la = xla; jj_lastpos = jj_scanpos = token;
3582 boolean retval = !jj_3_7();
3583 jj_save(6, xla);
3584 return retval;
3585 }
3586
3587 final private boolean jj_2_8(int xla) {
3588 jj_la = xla; jj_lastpos = jj_scanpos = token;
3589 boolean retval = !jj_3_8();
3590 jj_save(7, xla);
3591 return retval;
3592 }
3593
3594 final private boolean jj_2_9(int xla) {
3595 jj_la = xla; jj_lastpos = jj_scanpos = token;
3596 boolean retval = !jj_3_9();
3597 jj_save(8, xla);
3598 return retval;
3599 }
3600
3601 final private boolean jj_2_10(int xla) {
3602 jj_la = xla; jj_lastpos = jj_scanpos = token;
3603 boolean retval = !jj_3_10();
3604 jj_save(9, xla);
3605 return retval;
3606 }
3607
3608 final private boolean jj_2_11(int xla) {
3609 jj_la = xla; jj_lastpos = jj_scanpos = token;
3610 boolean retval = !jj_3_11();
3611 jj_save(10, xla);
3612 return retval;
3613 }
3614
3615 final private boolean jj_2_12(int xla) {
3616 jj_la = xla; jj_lastpos = jj_scanpos = token;
3617 boolean retval = !jj_3_12();
3618 jj_save(11, xla);
3619 return retval;
3620 }
3621
3622 final private boolean jj_2_13(int xla) {
3623 jj_la = xla; jj_lastpos = jj_scanpos = token;
3624 boolean retval = !jj_3_13();
3625 jj_save(12, xla);
3626 return retval;
3627 }
3628
3629 final private boolean jj_2_14(int xla) {
3630 jj_la = xla; jj_lastpos = jj_scanpos = token;
3631 boolean retval = !jj_3_14();
3632 jj_save(13, xla);
3633 return retval;
3634 }
3635
3636 final private boolean jj_2_15(int xla) {
3637 jj_la = xla; jj_lastpos = jj_scanpos = token;
3638 boolean retval = !jj_3_15();
3639 jj_save(14, xla);
3640 return retval;
3641 }
3642
3643 final private boolean jj_2_16(int xla) {
3644 jj_la = xla; jj_lastpos = jj_scanpos = token;
3645 boolean retval = !jj_3_16();
3646 jj_save(15, xla);
3647 return retval;
3648 }
3649
3650 final private boolean jj_2_17(int xla) {
3651 jj_la = xla; jj_lastpos = jj_scanpos = token;
3652 boolean retval = !jj_3_17();
3653 jj_save(16, xla);
3654 return retval;
3655 }
3656
3657 final private boolean jj_2_18(int xla) {
3658 jj_la = xla; jj_lastpos = jj_scanpos = token;
3659 boolean retval = !jj_3_18();
3660 jj_save(17, xla);
3661 return retval;
3662 }
3663
3664 final private boolean jj_2_19(int xla) {
3665 jj_la = xla; jj_lastpos = jj_scanpos = token;
3666 boolean retval = !jj_3_19();
3667 jj_save(18, xla);
3668 return retval;
3669 }
3670
3671 final private boolean jj_2_20(int xla) {
3672 jj_la = xla; jj_lastpos = jj_scanpos = token;
3673 boolean retval = !jj_3_20();
3674 jj_save(19, xla);
3675 return retval;
3676 }
3677
3678 final private boolean jj_2_21(int xla) {
3679 jj_la = xla; jj_lastpos = jj_scanpos = token;
3680 boolean retval = !jj_3_21();
3681 jj_save(20, xla);
3682 return retval;
3683 }
3684
3685 final private boolean jj_2_22(int xla) {
3686 jj_la = xla; jj_lastpos = jj_scanpos = token;
3687 boolean retval = !jj_3_22();
3688 jj_save(21, xla);
3689 return retval;
3690 }
3691
3692 final private boolean jj_2_23(int xla) {
3693 jj_la = xla; jj_lastpos = jj_scanpos = token;
3694 boolean retval = !jj_3_23();
3695 jj_save(22, xla);
3696 return retval;
3697 }
3698
3699 final private boolean jj_2_24(int xla) {
3700 jj_la = xla; jj_lastpos = jj_scanpos = token;
3701 boolean retval = !jj_3_24();
3702 jj_save(23, xla);
3703 return retval;
3704 }
3705
3706 final private boolean jj_2_25(int xla) {
3707 jj_la = xla; jj_lastpos = jj_scanpos = token;
3708 boolean retval = !jj_3_25();
3709 jj_save(24, xla);
3710 return retval;
3711 }
3712
3713 final private boolean jj_2_26(int xla) {
3714 jj_la = xla; jj_lastpos = jj_scanpos = token;
3715 boolean retval = !jj_3_26();
3716 jj_save(25, xla);
3717 return retval;
3718 }
3719
3720 final private boolean jj_2_27(int xla) {
3721 jj_la = xla; jj_lastpos = jj_scanpos = token;
3722 boolean retval = !jj_3_27();
3723 jj_save(26, xla);
3724 return retval;
3725 }
3726
3727 final private boolean jj_2_28(int xla) {
3728 jj_la = xla; jj_lastpos = jj_scanpos = token;
3729 boolean retval = !jj_3_28();
3730 jj_save(27, xla);
3731 return retval;
3732 }
3733
3734 final private boolean jj_2_29(int xla) {
3735 jj_la = xla; jj_lastpos = jj_scanpos = token;
3736 boolean retval = !jj_3_29();
3737 jj_save(28, xla);
3738 return retval;
3739 }
3740
3741 final private boolean jj_2_30(int xla) {
3742 jj_la = xla; jj_lastpos = jj_scanpos = token;
3743 boolean retval = !jj_3_30();
3744 jj_save(29, xla);
3745 return retval;
3746 }
3747
3748 final private boolean jj_2_31(int xla) {
3749 jj_la = xla; jj_lastpos = jj_scanpos = token;
3750 boolean retval = !jj_3_31();
3751 jj_save(30, xla);
3752 return retval;
3753 }
3754
3755 final private boolean jj_3R_170() {
3756 Token xsp;
3757 xsp = jj_scanpos;
3758 if (jj_3R_180()) {
3759 jj_scanpos = xsp;
3760 if (jj_3R_181()) {
3761 jj_scanpos = xsp;
3762 if (jj_3R_182()) {
3763 jj_scanpos = xsp;
3764 if (jj_3R_183()) {
3765 jj_scanpos = xsp;
3766 if (jj_3R_184()) {
3767 jj_scanpos = xsp;
3768 if (jj_3R_185()) return true;
3769 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3770 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3771 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3772 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3773 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3774 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3775 return false;
3776 }
3777
3778 final private boolean jj_3R_180() {
3779 if (jj_scan_token(INTEGER_LITERAL)) return true;
3780 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3781 return false;
3782 }
3783
3784 final private boolean jj_3R_147() {
3785 if (jj_scan_token(NATIVE)) return true;
3786 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3787 return false;
3788 }
3789
3790 final private boolean jj_3R_132() {
3791 if (jj_3R_64()) return true;
3792 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3793 return false;
3794 }
3795
3796 final private boolean jj_3R_164() {
3797 if (jj_scan_token(SUPER)) return true;
3798 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3799 return false;
3800 }
3801
3802 final private boolean jj_3R_131() {
3803 if (jj_scan_token(DOT)) return true;
3804 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3805 if (jj_scan_token(IDENTIFIER)) return true;
3806 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3807 return false;
3808 }
3809
3810 final private boolean jj_3R_130() {
3811 if (jj_scan_token(LBRACKET)) return true;
3812 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3813 if (jj_3R_70()) return true;
3814 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3815 if (jj_scan_token(RBRACKET)) return true;
3816 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3817 return false;
3818 }
3819
3820 final private boolean jj_3R_95() {
3821 if (jj_scan_token(STRICTFP)) return true;
3822 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3823 return false;
3824 }
3825
3826 final private boolean jj_3_23() {
3827 if (jj_scan_token(DOT)) return true;
3828 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3829 if (jj_3R_69()) return true;
3830 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3831 return false;
3832 }
3833
3834 final private boolean jj_3R_88() {
3835 if (jj_scan_token(STRICTFP)) return true;
3836 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3837 return false;
3838 }
3839
3840 final private boolean jj_3R_332() {
3841 if (jj_scan_token(STRICTFP)) return true;
3842 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3843 return false;
3844 }
3845
3846 final private boolean jj_3R_146() {
3847 if (jj_scan_token(FINAL)) return true;
3848 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3849 return false;
3850 }
3851
3852 final private boolean jj_3R_163() {
3853 if (jj_scan_token(THIS)) return true;
3854 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3855 return false;
3856 }
3857
3858 final private boolean jj_3_22() {
3859 if (jj_scan_token(DOT)) return true;
3860 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3861 if (jj_scan_token(SUPER)) return true;
3862 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3863 return false;
3864 }
3865
3866 final private boolean jj_3_20() {
3867 if (jj_3R_68()) return true;
3868 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3869 if (jj_scan_token(DOT)) return true;
3870 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3871 if (jj_scan_token(CLASS)) return true;
3872 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3873 return false;
3874 }
3875
3876 final private boolean jj_3R_331() {
3877 if (jj_scan_token(PRIVATE)) return true;
3878 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3879 return false;
3880 }
3881
3882 final private boolean jj_3_21() {
3883 if (jj_scan_token(DOT)) return true;
3884 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3885 if (jj_scan_token(THIS)) return true;
3886 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3887 return false;
3888 }
3889
3890 final private boolean jj_3R_67() {
3891 Token xsp;
3892 xsp = jj_scanpos;
3893 if (jj_3_21()) {
3894 jj_scanpos = xsp;
3895 if (jj_3_22()) {
3896 jj_scanpos = xsp;
3897 if (jj_3_23()) {
3898 jj_scanpos = xsp;
3899 if (jj_3R_130()) {
3900 jj_scanpos = xsp;
3901 if (jj_3R_131()) {
3902 jj_scanpos = xsp;
3903 if (jj_3R_132()) return true;
3904 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3905 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3906 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3907 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3908 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3909 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3910 return false;
3911 }
3912
3913 final private boolean jj_3R_330() {
3914 if (jj_scan_token(PROTECTED)) return true;
3915 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3916 return false;
3917 }
3918
3919 final private boolean jj_3R_94() {
3920 if (jj_scan_token(PRIVATE)) return true;
3921 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3922 return false;
3923 }
3924
3925 final private boolean jj_3R_157() {
3926 if (jj_3R_57()) return true;
3927 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3928 return false;
3929 }
3930
3931 final private boolean jj_3R_87() {
3932 if (jj_scan_token(PRIVATE)) return true;
3933 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3934 return false;
3935 }
3936
3937 final private boolean jj_3_19() {
3938 if (jj_3R_67()) return true;
3939 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3940 return false;
3941 }
3942
3943 final private boolean jj_3R_329() {
3944 if (jj_scan_token(PUBLIC)) return true;
3945 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3946 return false;
3947 }
3948
3949 final private boolean jj_3R_156() {
3950 if (jj_3R_68()) return true;
3951 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3952 if (jj_scan_token(DOT)) return true;
3953 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3954 if (jj_scan_token(CLASS)) return true;
3955 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3956 return false;
3957 }
3958
3959 final private boolean jj_3R_145() {
3960 if (jj_scan_token(ABSTRACT)) return true;
3961 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3962 return false;
3963 }
3964
3965 final private boolean jj_3R_155() {
3966 if (jj_3R_69()) return true;
3967 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3968 return false;
3969 }
3970
3971 final private boolean jj_3R_430() {
3972 if (jj_scan_token(DECR)) return true;
3973 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3974 return false;
3975 }
3976
3977 final private boolean jj_3R_328() {
3978 if (jj_scan_token(FINAL)) return true;
3979 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3980 return false;
3981 }
3982
3983 final private boolean jj_3R_162() {
3984 if (jj_scan_token(IDENTIFIER)) return true;
3985 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3986 return false;
3987 }
3988
3989 final private boolean jj_3R_154() {
3990 if (jj_scan_token(LPAREN)) return true;
3991 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3992 if (jj_3R_70()) return true;
3993 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3994 if (jj_scan_token(RPAREN)) return true;
3995 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3996 return false;
3997 }
3998
3999 final private boolean jj_3R_153() {
4000 if (jj_scan_token(SUPER)) return true;
4001 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4002 if (jj_scan_token(DOT)) return true;
4003 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4004 if (jj_scan_token(IDENTIFIER)) return true;
4005 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4006 return false;
4007 }
4008
4009 final private boolean jj_3R_327() {
4010 if (jj_scan_token(ABSTRACT)) return true;
4011 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4012 return false;
4013 }
4014
4015 final private boolean jj_3R_152() {
4016 if (jj_scan_token(THIS)) return true;
4017 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4018 return false;
4019 }
4020
4021 final private boolean jj_3R_93() {
4022 if (jj_scan_token(PROTECTED)) return true;
4023 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4024 return false;
4025 }
4026
4027 final private boolean jj_3R_161() {
4028 if (jj_scan_token(LPAREN)) return true;
4029 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4030 return false;
4031 }
4032
4033 final private boolean jj_3R_429() {
4034 if (jj_scan_token(INCR)) return true;
4035 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4036 return false;
4037 }
4038
4039 final private boolean jj_3R_423() {
4040 Token xsp;
4041 xsp = jj_scanpos;
4042 if (jj_3R_429()) {
4043 jj_scanpos = xsp;
4044 if (jj_3R_430()) return true;
4045 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4046 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4047 return false;
4048 }
4049
4050 final private boolean jj_3R_151() {
4051 if (jj_3R_170()) return true;
4052 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4053 return false;
4054 }
4055
4056 final private boolean jj_3R_118() {
4057 Token xsp;
4058 xsp = jj_scanpos;
4059 if (jj_3R_151()) {
4060 jj_scanpos = xsp;
4061 if (jj_3R_152()) {
4062 jj_scanpos = xsp;
4063 if (jj_3R_153()) {
4064 jj_scanpos = xsp;
4065 if (jj_3R_154()) {
4066 jj_scanpos = xsp;
4067 if (jj_3R_155()) {
4068 jj_scanpos = xsp;
4069 if (jj_3R_156()) {
4070 jj_scanpos = xsp;
4071 if (jj_3R_157()) return true;
4072 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4073 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4074 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4075 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4076 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4077 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4078 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4079 return false;
4080 }
4081
4082 final private boolean jj_3R_326() {
4083 if (jj_scan_token(STATIC)) return true;
4084 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4085 return false;
4086 }
4087
4088 final private boolean jj_3R_295() {
4089 Token xsp;
4090 xsp = jj_scanpos;
4091 if (jj_3R_326()) {
4092 jj_scanpos = xsp;
4093 if (jj_3R_327()) {
4094 jj_scanpos = xsp;
4095 if (jj_3R_328()) {
4096 jj_scanpos = xsp;
4097 if (jj_3R_329()) {
4098 jj_scanpos = xsp;
4099 if (jj_3R_330()) {
4100 jj_scanpos = xsp;
4101 if (jj_3R_331()) {
4102 jj_scanpos = xsp;
4103 if (jj_3R_332()) return true;
4104 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4105 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4106 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4107 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4108 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4109 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4110 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4111 return false;
4112 }
4113
4114 final private boolean jj_3R_144() {
4115 if (jj_scan_token(STATIC)) return true;
4116 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4117 return false;
4118 }
4119
4120 final private boolean jj_3R_86() {
4121 if (jj_scan_token(PROTECTED)) return true;
4122 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4123 return false;
4124 }
4125
4126 final private boolean jj_3R_281() {
4127 Token xsp;
4128 while (true) {
4129 xsp = jj_scanpos;
4130 if (jj_3R_295()) { jj_scanpos = xsp; break; }
4131 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4132 }
4133 if (jj_3R_191()) return true;
4134 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4135 return false;
4136 }
4137
4138 final private boolean jj_3R_160() {
4139 if (jj_scan_token(BANG)) return true;
4140 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4141 return false;
4142 }
4143
4144 final private boolean jj_3_18() {
4145 if (jj_scan_token(LPAREN)) return true;
4146 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4147 if (jj_3R_66()) return true;
4148 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4149 return false;
4150 }
4151
4152 final private boolean jj_3R_63() {
4153 if (jj_3R_118()) return true;
4154 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4155 Token xsp;
4156 while (true) {
4157 xsp = jj_scanpos;
4158 if (jj_3_19()) { jj_scanpos = xsp; break; }
4159 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4160 }
4161 return false;
4162 }
4163
4164 final private boolean jj_3R_92() {
4165 if (jj_scan_token(PUBLIC)) return true;
4166 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4167 return false;
4168 }
4169
4170 final private boolean jj_3R_159() {
4171 if (jj_scan_token(TILDE)) return true;
4172 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4173 return false;
4174 }
4175
4176 final private boolean jj_3R_397() {
4177 if (jj_scan_token(LPAREN)) return true;
4178 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4179 if (jj_3R_73()) return true;
4180 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4181 if (jj_scan_token(RPAREN)) return true;
4182 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4183 if (jj_3R_316()) return true;
4184 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4185 return false;
4186 }
4187
4188 final private boolean jj_3R_85() {
4189 if (jj_scan_token(PUBLIC)) return true;
4190 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4191 return false;
4192 }
4193
4194 final private boolean jj_3R_143() {
4195 if (jj_scan_token(PRIVATE)) return true;
4196 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4197 return false;
4198 }
4199
4200 final private boolean jj_3R_396() {
4201 if (jj_scan_token(LPAREN)) return true;
4202 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4203 if (jj_3R_73()) return true;
4204 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4205 if (jj_scan_token(RPAREN)) return true;
4206 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4207 if (jj_3R_279()) return true;
4208 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4209 return false;
4210 }
4211
4212 final private boolean jj_3R_383() {
4213 Token xsp;
4214 xsp = jj_scanpos;
4215 if (jj_3R_396()) {
4216 jj_scanpos = xsp;
4217 if (jj_3R_397()) return true;
4218 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4219 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4220 return false;
4221 }
4222
4223 final private boolean jj_3R_98() {
4224 if (jj_scan_token(PRIVATE)) return true;
4225 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4226 return false;
4227 }
4228
4229 final private boolean jj_3R_91() {
4230 if (jj_scan_token(FINAL)) return true;
4231 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4232 return false;
4233 }
4234
4235 final private boolean jj_3_17() {
4236 if (jj_scan_token(LPAREN)) return true;
4237 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4238 if (jj_3R_57()) return true;
4239 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4240 if (jj_scan_token(LBRACKET)) return true;
4241 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4242 return false;
4243 }
4244
4245 final private boolean jj_3R_384() {
4246 if (jj_3R_63()) return true;
4247 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4248 Token xsp;
4249 xsp = jj_scanpos;
4250 if (jj_3R_423()) jj_scanpos = xsp;
4251 else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4252 return false;
4253 }
4254
4255 final private boolean jj_3R_84() {
4256 if (jj_scan_token(FINAL)) return true;
4257 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4258 return false;
4259 }
4260
4261 final private boolean jj_3R_142() {
4262 if (jj_scan_token(PROTECTED)) return true;
4263 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4264 return false;
4265 }
4266
4267 final private boolean jj_3R_121() {
4268 if (jj_scan_token(LPAREN)) return true;
4269 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4270 if (jj_3R_57()) return true;
4271 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4272 if (jj_scan_token(RPAREN)) return true;
4273 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4274 Token xsp;
4275 xsp = jj_scanpos;
4276 if (jj_3R_159()) {
4277 jj_scanpos = xsp;
4278 if (jj_3R_160()) {
4279 jj_scanpos = xsp;
4280 if (jj_3R_161()) {
4281 jj_scanpos = xsp;
4282 if (jj_3R_162()) {
4283 jj_scanpos = xsp;
4284 if (jj_3R_163()) {
4285 jj_scanpos = xsp;
4286 if (jj_3R_164()) {
4287 jj_scanpos = xsp;
4288 if (jj_3R_165()) {
4289 jj_scanpos = xsp;
4290 if (jj_3R_166()) return true;
4291 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4292 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4293 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4294 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4295 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4296 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4297 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4298 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4299 return false;
4300 }
4301
4302 final private boolean jj_3R_97() {
4303 if (jj_scan_token(PROTECTED)) return true;
4304 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4305 return false;
4306 }
4307
4308 final private boolean jj_3R_120() {
4309 if (jj_scan_token(LPAREN)) return true;
4310 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4311 if (jj_3R_57()) return true;
4312 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4313 if (jj_scan_token(LBRACKET)) return true;
4314 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4315 if (jj_scan_token(RBRACKET)) return true;
4316 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4317 return false;
4318 }
4319
4320 final private boolean jj_3R_90() {
4321 if (jj_scan_token(ABSTRACT)) return true;
4322 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4323 return false;
4324 }
4325
4326 final private boolean jj_3_16() {
4327 if (jj_scan_token(LPAREN)) return true;
4328 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4329 if (jj_3R_66()) return true;
4330 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4331 return false;
4332 }
4333
4334 final private boolean jj_3R_65() {
4335 Token xsp;
4336 xsp = jj_scanpos;
4337 if (jj_3_16()) {
4338 jj_scanpos = xsp;
4339 if (jj_3R_120()) {
4340 jj_scanpos = xsp;
4341 if (jj_3R_121()) return true;
4342 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4343 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4344 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4345 return false;
4346 }
4347
4348 final private boolean jj_3_15() {
4349 if (jj_3R_65()) return true;
4350 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4351 return false;
4352 }
4353
4354 final private boolean jj_3R_83() {
4355 if (jj_scan_token(ABSTRACT)) return true;
4356 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4357 return false;
4358 }
4359
4360 final private boolean jj_3R_141() {
4361 if (jj_scan_token(PUBLIC)) return true;
4362 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4363 return false;
4364 }
4365
4366 final private boolean jj_3R_99() {
4367 Token xsp;
4368 xsp = jj_scanpos;
4369 if (jj_3R_141()) {
4370 jj_scanpos = xsp;
4371 if (jj_3R_142()) {
4372 jj_scanpos = xsp;
4373 if (jj_3R_143()) {
4374 jj_scanpos = xsp;
4375 if (jj_3R_144()) {
4376 jj_scanpos = xsp;
4377 if (jj_3R_145()) {
4378 jj_scanpos = xsp;
4379 if (jj_3R_146()) {
4380 jj_scanpos = xsp;
4381 if (jj_3R_147()) {
4382 jj_scanpos = xsp;
4383 if (jj_3R_148()) {
4384 jj_scanpos = xsp;
4385 if (jj_3R_149()) return true;
4386 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4387 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4388 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4389 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4390 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4391 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4392 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4393 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4394 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4395 return false;
4396 }
4397
4398 final private boolean jj_3R_382() {
4399 if (jj_scan_token(BANG)) return true;
4400 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4401 return false;
4402 }
4403
4404 final private boolean jj_3_6() {
4405 if (jj_3R_58()) return true;
4406 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4407 return false;
4408 }
4409
4410 final private boolean jj_3R_96() {
4411 if (jj_scan_token(PUBLIC)) return true;
4412 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4413 return false;
4414 }
4415
4416 final private boolean jj_3R_56() {
4417 Token xsp;
4418 xsp = jj_scanpos;
4419 if (jj_3R_96()) {
4420 jj_scanpos = xsp;
4421 if (jj_3R_97()) {
4422 jj_scanpos = xsp;
4423 if (jj_3R_98()) return true;
4424 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4425 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4426 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4427 return false;
4428 }
4429
4430 final private boolean jj_3R_58() {
4431 Token xsp;
4432 while (true) {
4433 xsp = jj_scanpos;
4434 if (jj_3R_99()) { jj_scanpos = xsp; break; }
4435 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4436 }
4437 if (jj_3R_68()) return true;
4438 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4439 if (jj_scan_token(IDENTIFIER)) return true;
4440 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4441 if (jj_scan_token(LPAREN)) return true;
4442 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4443 return false;
4444 }
4445
4446 final private boolean jj_3R_368() {
4447 if (jj_3R_384()) return true;
4448 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4449 return false;
4450 }
4451
4452 final private boolean jj_3_5() {
4453 Token xsp;
4454 xsp = jj_scanpos;
4455 if (jj_3R_56()) jj_scanpos = xsp;
4456 else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4457 if (jj_3R_57()) return true;
4458 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4459 if (jj_scan_token(LPAREN)) return true;
4460 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4461 return false;
4462 }
4463
4464 final private boolean jj_3R_380() {
4465 if (jj_scan_token(REM)) return true;
4466 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4467 return false;
4468 }
4469
4470 final private boolean jj_3R_55() {
4471 Token xsp;
4472 xsp = jj_scanpos;
4473 if (jj_3R_89()) {
4474 jj_scanpos = xsp;
4475 if (jj_3R_90()) {
4476 jj_scanpos = xsp;
4477 if (jj_3R_91()) {
4478 jj_scanpos = xsp;
4479 if (jj_3R_92()) {
4480 jj_scanpos = xsp;
4481 if (jj_3R_93()) {
4482 jj_scanpos = xsp;
4483 if (jj_3R_94()) {
4484 jj_scanpos = xsp;
4485 if (jj_3R_95()) return true;
4486 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4487 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4488 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4489 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4490 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4491 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4492 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4493 return false;
4494 }
4495
4496 final private boolean jj_3R_89() {
4497 if (jj_scan_token(STATIC)) return true;
4498 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4499 return false;
4500 }
4501
4502 final private boolean jj_3R_381() {
4503 if (jj_scan_token(TILDE)) return true;
4504 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4505 return false;
4506 }
4507
4508 final private boolean jj_3R_367() {
4509 if (jj_3R_383()) return true;
4510 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4511 return false;
4512 }
4513
4514 final private boolean jj_3_4() {
4515 Token xsp;
4516 while (true) {
4517 xsp = jj_scanpos;
4518 if (jj_3R_55()) { jj_scanpos = xsp; break; }
4519 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4520 }
4521 if (jj_scan_token(INTERFACE)) return true;
4522 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4523 return false;
4524 }
4525
4526 final private boolean jj_3R_365() {
4527 if (jj_scan_token(MINUS)) return true;
4528 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4529 return false;
4530 }
4531
4532 final private boolean jj_3R_54() {
4533 Token xsp;
4534 xsp = jj_scanpos;
4535 if (jj_3R_82()) {
4536 jj_scanpos = xsp;
4537 if (jj_3R_83()) {
4538 jj_scanpos = xsp;
4539 if (jj_3R_84()) {
4540 jj_scanpos = xsp;
4541 if (jj_3R_85()) {
4542 jj_scanpos = xsp;
4543 if (jj_3R_86()) {
4544 jj_scanpos = xsp;
4545 if (jj_3R_87()) {
4546 jj_scanpos = xsp;
4547 if (jj_3R_88()) return true;
4548 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4549 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4550 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4551 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4552 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4553 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4554 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4555 return false;
4556 }
4557
4558 final private boolean jj_3R_82() {
4559 if (jj_scan_token(STATIC)) return true;
4560 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4561 return false;
4562 }
4563
4564 final private boolean jj_3R_366() {
4565 Token xsp;
4566 xsp = jj_scanpos;
4567 if (jj_3R_381()) {
4568 jj_scanpos = xsp;
4569 if (jj_3R_382()) return true;
4570 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4571 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4572 if (jj_3R_279()) return true;
4573 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4574 return false;
4575 }
4576
4577 final private boolean jj_3R_316() {
4578 Token xsp;
4579 xsp = jj_scanpos;
4580 if (jj_3R_366()) {
4581 jj_scanpos = xsp;
4582 if (jj_3R_367()) {
4583 jj_scanpos = xsp;
4584 if (jj_3R_368()) return true;
4585 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4586 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4587 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4588 return false;
4589 }
4590
4591 final private boolean jj_3R_277() {
4592 if (jj_3R_284()) return true;
4593 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4594 return false;
4595 }
4596
4597 final private boolean jj_3_3() {
4598 Token xsp;
4599 while (true) {
4600 xsp = jj_scanpos;
4601 if (jj_3R_54()) { jj_scanpos = xsp; break; }
4602 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4603 }
4604 if (jj_scan_token(CLASS)) return true;
4605 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4606 return false;
4607 }
4608
4609 final private boolean jj_3R_379() {
4610 if (jj_scan_token(SLASH)) return true;
4611 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4612 return false;
4613 }
4614
4615 final private boolean jj_3R_313() {
4616 if (jj_scan_token(RUNSIGNEDSHIFT)) return true;
4617 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4618 return false;
4619 }
4620
4621 final private boolean jj_3R_276() {
4622 if (jj_3R_283()) return true;
4623 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4624 return false;
4625 }
4626
4627 final private boolean jj_3R_364() {
4628 if (jj_scan_token(PLUS)) return true;
4629 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4630 return false;
4631 }
4632
4633 final private boolean jj_3R_275() {
4634 if (jj_3R_282()) return true;
4635 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4636 return false;
4637 }
4638
4639 final private boolean jj_3R_254() {
4640 if (jj_scan_token(DECR)) return true;
4641 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4642 if (jj_3R_63()) return true;
4643 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4644 return false;
4645 }
4646
4647 final private boolean jj_3R_310() {
4648 Token xsp;
4649 xsp = jj_scanpos;
4650 if (jj_3R_364()) {
4651 jj_scanpos = xsp;
4652 if (jj_3R_365()) return true;
4653 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4654 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4655 if (jj_3R_272()) return true;
4656 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4657 return false;
4658 }
4659
4660 final private boolean jj_3R_289() {
4661 if (jj_scan_token(GE)) return true;
4662 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4663 return false;
4664 }
4665
4666 final private boolean jj_3R_378() {
4667 if (jj_scan_token(STAR)) return true;
4668 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4669 return false;
4670 }
4671
4672 final private boolean jj_3R_274() {
4673 if (jj_3R_281()) return true;
4674 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4675 return false;
4676 }
4677
4678 final private boolean jj_3R_363() {
4679 Token xsp;
4680 xsp = jj_scanpos;
4681 if (jj_3R_378()) {
4682 jj_scanpos = xsp;
4683 if (jj_3R_379()) {
4684 jj_scanpos = xsp;
4685 if (jj_3R_380()) return true;
4686 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4687 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4688 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4689 if (jj_3R_279()) return true;
4690 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4691 return false;
4692 }
4693
4694 final private boolean jj_3R_312() {
4695 if (jj_scan_token(RSIGNEDSHIFT)) return true;
4696 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4697 return false;
4698 }
4699
4700 final private boolean jj_3R_273() {
4701 if (jj_3R_280()) return true;
4702 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4703 return false;
4704 }
4705
4706 final private boolean jj_3R_253() {
4707 if (jj_scan_token(INCR)) return true;
4708 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4709 if (jj_3R_63()) return true;
4710 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4711 return false;
4712 }
4713
4714 final private boolean jj_3R_288() {
4715 if (jj_scan_token(LE)) return true;
4716 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4717 return false;
4718 }
4719
4720 final private boolean jj_3_2() {
4721 if (jj_3R_53()) return true;
4722 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4723 return false;
4724 }
4725
4726 final private boolean jj_3R_268() {
4727 Token xsp;
4728 xsp = jj_scanpos;
4729 if (jj_3_2()) {
4730 jj_scanpos = xsp;
4731 if (jj_3R_273()) {
4732 jj_scanpos = xsp;
4733 if (jj_3R_274()) {
4734 jj_scanpos = xsp;
4735 if (jj_3R_275()) {
4736 jj_scanpos = xsp;
4737 if (jj_3R_276()) {
4738 jj_scanpos = xsp;
4739 if (jj_3R_277()) return true;
4740 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4741 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4742 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4743 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4744 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4745 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4746 return false;
4747 }
4748
4749 final private boolean jj_3R_315() {
4750 if (jj_scan_token(MINUS)) return true;
4751 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4752 return false;
4753 }
4754
4755 final private boolean jj_3R_311() {
4756 if (jj_scan_token(LSHIFT)) return true;
4757 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4758 return false;
4759 }
4760
4761 final private boolean jj_3R_293() {
4762 if (jj_3R_316()) return true;
4763 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4764 return false;
4765 }
4766
4767 final private boolean jj_3R_285() {
4768 Token xsp;
4769 xsp = jj_scanpos;
4770 if (jj_3R_311()) {
4771 jj_scanpos = xsp;
4772 if (jj_3R_312()) {
4773 jj_scanpos = xsp;
4774 if (jj_3R_313()) return true;
4775 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4776 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4777 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4778 if (jj_3R_267()) return true;
4779 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4780 return false;
4781 }
4782
4783 final private boolean jj_3R_287() {
4784 if (jj_scan_token(GT)) return true;
4785 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4786 return false;
4787 }
4788
4789 final private boolean jj_3R_292() {
4790 if (jj_3R_254()) return true;
4791 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4792 return false;
4793 }
4794
4795 final private boolean jj_3R_314() {
4796 if (jj_scan_token(PLUS)) return true;
4797 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4798 return false;
4799 }
4800
4801 final private boolean jj_3R_227() {
4802 if (jj_scan_token(ORASSIGN)) return true;
4803 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4804 return false;
4805 }
4806
4807 final private boolean jj_3R_291() {
4808 if (jj_3R_253()) return true;
4809 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4810 return false;
4811 }
4812
4813 final private boolean jj_3R_279() {
4814 Token xsp;
4815 xsp = jj_scanpos;
4816 if (jj_3R_290()) {
4817 jj_scanpos = xsp;
4818 if (jj_3R_291()) {
4819 jj_scanpos = xsp;
4820 if (jj_3R_292()) {
4821 jj_scanpos = xsp;
4822 if (jj_3R_293()) return true;
4823 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4824 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4825 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4826 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4827 return false;
4828 }
4829
4830 final private boolean jj_3R_290() {
4831 Token xsp;
4832 xsp = jj_scanpos;
4833 if (jj_3R_314()) {
4834 jj_scanpos = xsp;
4835 if (jj_3R_315()) return true;
4836 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4837 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4838 if (jj_3R_279()) return true;
4839 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4840 return false;
4841 }
4842
4843 final private boolean jj_3R_271() {
4844 if (jj_scan_token(NE)) return true;
4845 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4846 return false;
4847 }
4848
4849 final private boolean jj_3R_286() {
4850 if (jj_scan_token(LT)) return true;
4851 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4852 return false;
4853 }
4854
4855 final private boolean jj_3R_278() {
4856 Token xsp;
4857 xsp = jj_scanpos;
4858 if (jj_3R_286()) {
4859 jj_scanpos = xsp;
4860 if (jj_3R_287()) {
4861 jj_scanpos = xsp;
4862 if (jj_3R_288()) {
4863 jj_scanpos = xsp;
4864 if (jj_3R_289()) return true;
4865 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4866 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4867 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4868 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4869 if (jj_3R_262()) return true;
4870 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4871 return false;
4872 }
4873
4874 final private boolean jj_3R_323() {
4875 if (jj_scan_token(STRICTFP)) return true;
4876 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4877 return false;
4878 }
4879
4880 final private boolean jj_3R_226() {
4881 if (jj_scan_token(XORASSIGN)) return true;
4882 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4883 return false;
4884 }
4885
4886 final private boolean jj_3R_269() {
4887 if (jj_scan_token(INSTANCEOF)) return true;
4888 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4889 if (jj_3R_73()) return true;
4890 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4891 return false;
4892 }
4893
4894 final private boolean jj_3R_272() {
4895 if (jj_3R_279()) return true;
4896 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4897 Token xsp;
4898 while (true) {
4899 xsp = jj_scanpos;
4900 if (jj_3R_363()) { jj_scanpos = xsp; break; }
4901 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4902 }
4903 return false;
4904 }
4905
4906 final private boolean jj_3R_322() {
4907 if (jj_scan_token(PRIVATE)) return true;
4908 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4909 return false;
4910 }
4911
4912 final private boolean jj_3R_270() {
4913 if (jj_scan_token(EQ)) return true;
4914 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4915 return false;
4916 }
4917
4918 final private boolean jj_3R_266() {
4919 Token xsp;
4920 xsp = jj_scanpos;
4921 if (jj_3R_270()) {
4922 jj_scanpos = xsp;
4923 if (jj_3R_271()) return true;
4924 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4925 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4926 if (jj_3R_252()) return true;
4927 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4928 return false;
4929 }
4930
4931 final private boolean jj_3R_225() {
4932 if (jj_scan_token(ANDASSIGN)) return true;
4933 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4934 return false;
4935 }
4936
4937 final private boolean jj_3R_267() {
4938 if (jj_3R_272()) return true;
4939 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4940 Token xsp;
4941 while (true) {
4942 xsp = jj_scanpos;
4943 if (jj_3R_310()) { jj_scanpos = xsp; break; }
4944 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4945 }
4946 return false;
4947 }
4948
4949 final private boolean jj_3R_321() {
4950 if (jj_scan_token(PROTECTED)) return true;
4951 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4952 return false;
4953 }
4954
4955 final private boolean jj_3R_320() {
4956 if (jj_scan_token(PUBLIC)) return true;
4957 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4958 return false;
4959 }
4960
4961 final private boolean jj_3R_262() {
4962 if (jj_3R_267()) return true;
4963 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4964 Token xsp;
4965 while (true) {
4966 xsp = jj_scanpos;
4967 if (jj_3R_285()) { jj_scanpos = xsp; break; }
4968 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4969 }
4970 return false;
4971 }
4972
4973 final private boolean jj_3R_261() {
4974 if (jj_scan_token(BIT_AND)) return true;
4975 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4976 if (jj_3R_244()) return true;
4977 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4978 return false;
4979 }
4980
4981 final private boolean jj_3R_319() {
4982 if (jj_scan_token(FINAL)) return true;
4983 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4984 return false;
4985 }
4986
4987 final private boolean jj_3R_224() {
4988 if (jj_scan_token(RUNSIGNEDSHIFTASSIGN)) return true;
4989 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4990 return false;
4991 }
4992
4993 final private boolean jj_3R_258() {
4994 if (jj_3R_262()) return true;
4995 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4996 Token xsp;
4997 while (true) {
4998 xsp = jj_scanpos;
4999 if (jj_3R_278()) { jj_scanpos = xsp; break; }
5000 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5001 }
5002 return false;
5003 }
5004
5005 final private boolean jj_3R_318() {
5006 if (jj_scan_token(ABSTRACT)) return true;
5007 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5008 return false;
5009 }
5010
5011 final private boolean jj_3R_251() {
5012 if (jj_scan_token(BIT_OR)) return true;
5013 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5014 if (jj_3R_196()) return true;
5015 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5016 return false;
5017 }
5018
5019 final private boolean jj_3R_317() {
5020 if (jj_scan_token(STATIC)) return true;
5021 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5022 return false;
5023 }
5024
5025 final private boolean jj_3R_294() {
5026 Token xsp;
5027 xsp = jj_scanpos;
5028 if (jj_3R_317()) {
5029 jj_scanpos = xsp;
5030 if (jj_3R_318()) {
5031 jj_scanpos = xsp;
5032 if (jj_3R_319()) {
5033 jj_scanpos = xsp;
5034 if (jj_3R_320()) {
5035 jj_scanpos = xsp;
5036 if (jj_3R_321()) {
5037 jj_scanpos = xsp;
5038 if (jj_3R_322()) {
5039 jj_scanpos = xsp;
5040 if (jj_3R_323()) return true;
5041 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5042 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5043 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5044 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5045 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5046 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5047 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5048 return false;
5049 }
5050
5051 final private boolean jj_3R_223() {
5052 if (jj_scan_token(RSIGNEDSHIFTASSIGN)) return true;
5053 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5054 return false;
5055 }
5056
5057 final private boolean jj_3R_252() {
5058 if (jj_3R_258()) return true;
5059 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5060 Token xsp;
5061 xsp = jj_scanpos;
5062 if (jj_3R_269()) jj_scanpos = xsp;
5063 else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5064 return false;
5065 }
5066
5067 final private boolean jj_3R_257() {
5068 if (jj_scan_token(XOR)) return true;
5069 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5070 if (jj_3R_228()) return true;
5071 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5072 return false;
5073 }
5074
5075 final private boolean jj_3R_280() {
5076 Token xsp;
5077 while (true) {
5078 xsp = jj_scanpos;
5079 if (jj_3R_294()) { jj_scanpos = xsp; break; }
5080 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5081 }
5082 if (jj_3R_190()) return true;
5083 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5084 return false;
5085 }
5086
5087 final private boolean jj_3R_243() {
5088 if (jj_scan_token(SC_AND)) return true;
5089 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5090 if (jj_3R_187()) return true;
5091 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5092 return false;
5093 }
5094
5095 final private boolean jj_3R_265() {
5096 if (jj_3R_268()) return true;
5097 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5098 return false;
5099 }
5100
5101 final private boolean jj_3R_244() {
5102 if (jj_3R_252()) return true;
5103 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5104 Token xsp;
5105 while (true) {
5106 xsp = jj_scanpos;
5107 if (jj_3R_266()) { jj_scanpos = xsp; break; }
5108 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5109 }
5110 return false;
5111 }
5112
5113 final private boolean jj_3R_215() {
5114 if (jj_scan_token(SC_OR)) return true;
5115 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5116 if (jj_3R_175()) return true;
5117 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5118 return false;
5119 }
5120
5121 final private boolean jj_3R_222() {
5122 if (jj_scan_token(LSHIFTASSIGN)) return true;
5123 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5124 return false;
5125 }
5126
5127 final private boolean jj_3R_260() {
5128 if (jj_scan_token(LBRACE)) return true;
5129 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5130 Token xsp;
5131 while (true) {
5132 xsp = jj_scanpos;
5133 if (jj_3R_265()) { jj_scanpos = xsp; break; }
5134 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5135 }
5136 if (jj_scan_token(RBRACE)) return true;
5137 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5138 return false;
5139 }
5140
5141 final private boolean jj_3R_228() {
5142 if (jj_3R_244()) return true;
5143 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5144 Token xsp;
5145 while (true) {
5146 xsp = jj_scanpos;
5147 if (jj_3R_261()) { jj_scanpos = xsp; break; }
5148 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5149 }
5150 return false;
5151 }
5152
5153 final private boolean jj_3R_194() {
5154 if (jj_scan_token(HOOK)) return true;
5155 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5156 if (jj_3R_70()) return true;
5157 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5158 if (jj_scan_token(COLON)) return true;
5159 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5160 if (jj_3R_136()) return true;
5161 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5162 return false;
5163 }
5164
5165 final private boolean jj_3R_221() {
5166 if (jj_scan_token(MINUSASSIGN)) return true;
5167 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5168 return false;
5169 }
5170
5171 final private boolean jj_3R_196() {
5172 if (jj_3R_228()) return true;
5173 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5174 Token xsp;
5175 while (true) {
5176 xsp = jj_scanpos;
5177 if (jj_3R_257()) { jj_scanpos = xsp; break; }
5178 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5179 }
5180 return false;
5181 }
5182
5183 final private boolean jj_3R_220() {
5184 if (jj_scan_token(PLUSASSIGN)) return true;
5185 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5186 return false;
5187 }
5188
5189 final private boolean jj_3R_325() {
5190 if (jj_scan_token(IMPLEMENTS)) return true;
5191 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5192 if (jj_3R_369()) return true;
5193 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5194 return false;
5195 }
5196
5197 final private boolean jj_3R_324() {
5198 if (jj_scan_token(EXTENDS)) return true;
5199 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5200 if (jj_3R_57()) return true;
5201 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5202 return false;
5203 }
5204
5205 final private boolean jj_3R_187() {
5206 if (jj_3R_196()) return true;
5207 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5208 Token xsp;
5209 while (true) {
5210 xsp = jj_scanpos;
5211 if (jj_3R_251()) { jj_scanpos = xsp; break; }
5212 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5213 }
5214 return false;
5215 }
5216
5217 final private boolean jj_3R_219() {
5218 if (jj_scan_token(REMASSIGN)) return true;
5219 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5220 return false;
5221 }
5222
5223 final private boolean jj_3R_175() {
5224 if (jj_3R_187()) return true;
5225 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5226 Token xsp;
5227 while (true) {
5228 xsp = jj_scanpos;
5229 if (jj_3R_243()) { jj_scanpos = xsp; break; }
5230 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5231 }
5232 return false;
5233 }
5234
5235 final private boolean jj_3R_218() {
5236 if (jj_scan_token(SLASHASSIGN)) return true;
5237 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5238 return false;
5239 }
5240
5241 final private boolean jj_3R_168() {
5242 if (jj_3R_175()) return true;
5243 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5244 Token xsp;
5245 while (true) {
5246 xsp = jj_scanpos;
5247 if (jj_3R_215()) { jj_scanpos = xsp; break; }
5248 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5249 }
5250 return false;
5251 }
5252
5253 final private boolean jj_3R_136() {
5254 if (jj_3R_168()) return true;
5255 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5256 Token xsp;
5257 xsp = jj_scanpos;
5258 if (jj_3R_194()) jj_scanpos = xsp;
5259 else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5260 return false;
5261 }
5262
5263 final private boolean jj_3R_217() {
5264 if (jj_scan_token(STARASSIGN)) return true;
5265 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5266 return false;
5267 }
5268
5269 final private boolean jj_3R_190() {
5270 if (jj_scan_token(CLASS)) return true;
5271 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5272 if (jj_scan_token(IDENTIFIER)) return true;
5273 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5274 Token xsp;
5275 xsp = jj_scanpos;
5276 if (jj_3R_324()) jj_scanpos = xsp;
5277 else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5278 xsp = jj_scanpos;
5279 if (jj_3R_325()) jj_scanpos = xsp;
5280 else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5281 if (jj_3R_260()) return true;
5282 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5283 return false;
5284 }
5285
5286 final private boolean jj_3R_195() {
5287 Token xsp;
5288 xsp = jj_scanpos;
5289 if (jj_3R_216()) {
5290 jj_scanpos = xsp;
5291 if (jj_3R_217()) {
5292 jj_scanpos = xsp;
5293 if (jj_3R_218()) {
5294 jj_scanpos = xsp;
5295 if (jj_3R_219()) {
5296 jj_scanpos = xsp;
5297 if (jj_3R_220()) {
5298 jj_scanpos = xsp;
5299 if (jj_3R_221()) {
5300 jj_scanpos = xsp;
5301 if (jj_3R_222()) {
5302 jj_scanpos = xsp;
5303 if (jj_3R_223()) {
5304 jj_scanpos = xsp;
5305 if (jj_3R_224()) {
5306 jj_scanpos = xsp;
5307 if (jj_3R_225()) {
5308 jj_scanpos = xsp;
5309 if (jj_3R_226()) {
5310 jj_scanpos = xsp;
5311 if (jj_3R_227()) return true;
5312 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5313 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5314 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5315 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5316 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5317 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5318 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5319 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5320 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5321 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5322 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5323 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5324 return false;
5325 }
5326
5327 final private boolean jj_3R_216() {
5328 if (jj_scan_token(ASSIGN)) return true;
5329 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5330 return false;
5331 }
5332
5333 final private boolean jj_3R_186() {
5334 if (jj_3R_195()) return true;
5335 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5336 if (jj_3R_70()) return true;
5337 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5338 return false;
5339 }
5340
5341 final private boolean jj_3R_70() {
5342 if (jj_3R_136()) return true;
5343 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5344 Token xsp;
5345 xsp = jj_scanpos;
5346 if (jj_3R_186()) jj_scanpos = xsp;
5347 else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5348 return false;
5349 }
5350
5351 final private boolean jj_3R_79() {
5352 if (jj_scan_token(STRICTFP)) return true;
5353 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5354 return false;
5355 }
5356
5357 final private boolean jj_3R_386() {
5358 if (jj_scan_token(COMMA)) return true;
5359 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5360 if (jj_3R_385()) return true;
5361 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5362 return false;
5363 }
5364
5365 final private boolean jj_3R_78() {
5366 if (jj_scan_token(PUBLIC)) return true;
5367 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5368 return false;
5369 }
5370
5371 final private boolean jj_3R_369() {
5372 if (jj_3R_385()) return true;
5373 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5374 Token xsp;
5375 while (true) {
5376 xsp = jj_scanpos;
5377 if (jj_3R_386()) { jj_scanpos = xsp; break; }
5378 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5379 }
5380 return false;
5381 }
5382
5383 final private boolean jj_3R_374() {
5384 if (jj_scan_token(COMMA)) return true;
5385 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5386 if (jj_3R_373()) return true;
5387 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5388 return false;
5389 }
5390
5391 final private boolean jj_3R_339() {
5392 if (jj_3R_373()) return true;
5393 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5394 Token xsp;
5395 while (true) {
5396 xsp = jj_scanpos;
5397 if (jj_3R_374()) { jj_scanpos = xsp; break; }
5398 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5399 }
5400 return false;
5401 }
5402
5403 final private boolean jj_3R_77() {
5404 if (jj_scan_token(FINAL)) return true;
5405 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5406 return false;
5407 }
5408
5409 final private boolean jj_3R_52() {
5410 Token xsp;
5411 xsp = jj_scanpos;
5412 if (jj_3R_76()) {
5413 jj_scanpos = xsp;
5414 if (jj_3R_77()) {
5415 jj_scanpos = xsp;
5416 if (jj_3R_78()) {
5417 jj_scanpos = xsp;
5418 if (jj_3R_79()) return true;
5419 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5420 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5421 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5422 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5423 return false;
5424 }
5425
5426 final private boolean jj_3R_76() {
5427 if (jj_scan_token(ABSTRACT)) return true;
5428 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5429 return false;
5430 }
5431
5432 final private boolean jj_3_1() {
5433 Token xsp;
5434 while (true) {
5435 xsp = jj_scanpos;
5436 if (jj_3R_52()) { jj_scanpos = xsp; break; }
5437 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5438 }
5439 if (jj_scan_token(CLASS)) return true;
5440 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5441 return false;
5442 }
5443
5444 final private boolean jj_3R_398() {
5445 if (jj_scan_token(DOT)) return true;
5446 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5447 if (jj_scan_token(IDENTIFIER)) return true;
5448 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5449 return false;
5450 }
5451
5452 final private boolean jj_3R_385() {
5453 if (jj_scan_token(IDENTIFIER)) return true;
5454 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5455 Token xsp;
5456 while (true) {
5457 xsp = jj_scanpos;
5458 if (jj_3R_398()) { jj_scanpos = xsp; break; }
5459 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5460 }
5461 return false;
5462 }
5463
5464 final private boolean jj_3R_394() {
5465 if (jj_scan_token(DOT)) return true;
5466 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5467 if (jj_scan_token(IDENTIFIER)) return true;
5468 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5469 return false;
5470 }
5471
5472 final private boolean jj_3R_373() {
5473 if (jj_scan_token(IDENTIFIER)) return true;
5474 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5475 Token xsp;
5476 while (true) {
5477 xsp = jj_scanpos;
5478 if (jj_3R_394()) { jj_scanpos = xsp; break; }
5479 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5480 }
5481 return false;
5482 }
5483
5484 final private boolean jj_3_14() {
5485 if (jj_scan_token(DOT)) return true;
5486 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5487 if (jj_scan_token(IDENTIFIER)) return true;
5488 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5489 return false;
5490 }
5491
5492 final private boolean jj_3R_57() {
5493 if (jj_scan_token(IDENTIFIER)) return true;
5494 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5495 Token xsp;
5496 while (true) {
5497 xsp = jj_scanpos;
5498 if (jj_3_14()) { jj_scanpos = xsp; break; }
5499 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5500 }
5501 return false;
5502 }
5503
5504 final private boolean jj_3R_134() {
5505 if (jj_3R_167()) return true;
5506 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5507 return false;
5508 }
5509
5510 final private boolean jj_3R_133() {
5511 if (jj_scan_token(VOID)) return true;
5512 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5513 return false;
5514 }
5515
5516 final private boolean jj_3R_68() {
5517 Token xsp;
5518 xsp = jj_scanpos;
5519 if (jj_3R_133()) {
5520 jj_scanpos = xsp;
5521 if (jj_3R_134()) return true;
5522 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5523 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5524 return false;
5525 }
5526
5527 final private boolean jj_3R_129() {
5528 if (jj_scan_token(DOUBLE)) return true;
5529 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5530 return false;
5531 }
5532
5533 final private boolean jj_3R_128() {
5534 if (jj_scan_token(FLOAT)) return true;
5535 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5536 return false;
5537 }
5538
5539 final private boolean jj_3R_138() {
5540 if (jj_3R_57()) return true;
5541 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5542 return false;
5543 }
5544
5545 final private boolean jj_3R_127() {
5546 if (jj_scan_token(LONG)) return true;
5547 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5548 return false;
5549 }
5550
5551 final private boolean jj_3R_126() {
5552 if (jj_scan_token(INT)) return true;
5553 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5554 return false;
5555 }
5556
5557 final private boolean jj_3R_125() {
5558 if (jj_scan_token(SHORT)) return true;
5559 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5560 return false;
5561 }
5562
5563 final private boolean jj_3R_124() {
5564 if (jj_scan_token(BYTE)) return true;
5565 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5566 return false;
5567 }
5568
5569 final private boolean jj_3R_123() {
5570 if (jj_scan_token(CHAR)) return true;
5571 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5572 return false;
5573 }
5574
5575 final private boolean jj_3R_122() {
5576 if (jj_scan_token(BOOLEAN)) return true;
5577 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5578 return false;
5579 }
5580
5581 final private boolean jj_3R_66() {
5582 Token xsp;
5583 xsp = jj_scanpos;
5584 if (jj_3R_122()) {
5585 jj_scanpos = xsp;
5586 if (jj_3R_123()) {
5587 jj_scanpos = xsp;
5588 if (jj_3R_124()) {
5589 jj_scanpos = xsp;
5590 if (jj_3R_125()) {
5591 jj_scanpos = xsp;
5592 if (jj_3R_126()) {
5593 jj_scanpos = xsp;
5594 if (jj_3R_127()) {
5595 jj_scanpos = xsp;
5596 if (jj_3R_128()) {
5597 jj_scanpos = xsp;
5598 if (jj_3R_129()) return true;
5599 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5600 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5601 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5602 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5603 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5604 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5605 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5606 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5607 return false;
5608 }
5609
5610 final private boolean jj_3R_139() {
5611 if (jj_scan_token(LBRACKET)) return true;
5612 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5613 if (jj_scan_token(RBRACKET)) return true;
5614 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5615 return false;
5616 }
5617
5618 final private boolean jj_3R_137() {
5619 if (jj_3R_66()) return true;
5620 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5621 return false;
5622 }
5623
5624 final private boolean jj_3R_73() {
5625 Token xsp;
5626 xsp = jj_scanpos;
5627 if (jj_3R_137()) {
5628 jj_scanpos = xsp;
5629 if (jj_3R_138()) return true;
5630 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5631 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5632 while (true) {
5633 xsp = jj_scanpos;
5634 if (jj_3R_139()) { jj_scanpos = xsp; break; }
5635 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5636 }
5637 return false;
5638 }
5639
5640 final private boolean jj_3R_401() {
5641 if (jj_scan_token(LBRACKET)) return true;
5642 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5643 if (jj_scan_token(RBRACKET)) return true;
5644 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5645 return false;
5646 }
5647
5648 final private boolean jj_3R_400() {
5649 if (jj_3R_57()) return true;
5650 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5651 return false;
5652 }
5653
5654 final private boolean jj_3R_399() {
5655 if (jj_3R_66()) return true;
5656 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5657 return false;
5658 }
5659
5660 final private boolean jj_3R_392() {
5661 Token xsp;
5662 xsp = jj_scanpos;
5663 if (jj_3R_399()) {
5664 jj_scanpos = xsp;
5665 if (jj_3R_400()) return true;
5666 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5667 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5668 while (true) {
5669 xsp = jj_scanpos;
5670 if (jj_3R_401()) { jj_scanpos = xsp; break; }
5671 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5672 }
5673 return false;
5674 }
5675
5676 final private boolean jj_3R_174() {
5677 if (jj_scan_token(LBRACKET)) return true;
5678 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5679 if (jj_scan_token(RBRACKET)) return true;
5680 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5681 return false;
5682 }
5683
5684 final private boolean jj_3R_173() {
5685 if (jj_3R_57()) return true;
5686 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5687 return false;
5688 }
5689
5690 final private boolean jj_3R_172() {
5691 if (jj_3R_66()) return true;
5692 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5693 return false;
5694 }
5695
5696 final private boolean jj_3R_167() {
5697 Token xsp;
5698 xsp = jj_scanpos;
5699 if (jj_3R_172()) {
5700 jj_scanpos = xsp;
5701 if (jj_3R_173()) return true;
5702 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5703 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5704 while (true) {
5705 xsp = jj_scanpos;
5706 if (jj_3R_174()) { jj_scanpos = xsp; break; }
5707 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5708 }
5709 return false;
5710 }
5711
5712 final private boolean jj_3R_422() {
5713 if (jj_scan_token(COLON)) return true;
5714 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5715 if (jj_3R_70()) return true;
5716 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5717 return false;
5718 }
5719
5720 final private boolean jj_3R_360() {
5721 if (jj_scan_token(LBRACKET)) return true;
5722 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5723 if (jj_scan_token(RBRACKET)) return true;
5724 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5725 return false;
5726 }
5727
5728 final private boolean jj_3R_359() {
5729 if (jj_3R_57()) return true;
5730 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5731 return false;
5732 }
5733
5734 final private boolean jj_3R_298() {
5735 if (jj_scan_token(THROWS)) return true;
5736 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5737 if (jj_3R_339()) return true;
5738 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5739 return false;
5740 }
5741
5742 final private boolean jj_3R_242() {
5743 if (jj_scan_token(ASSERT)) return true;
5744 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5745 if (jj_3R_70()) return true;
5746 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5747 Token xsp;
5748 xsp = jj_scanpos;
5749 if (jj_3R_422()) jj_scanpos = xsp;
5750 else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5751 if (jj_scan_token(SEMICOLON)) return true;
5752 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5753 return false;
5754 }
5755
5756 final private boolean jj_3R_358() {
5757 if (jj_3R_66()) return true;
5758 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5759 return false;
5760 }
5761
5762 final private boolean jj_3R_307() {
5763 Token xsp;
5764 xsp = jj_scanpos;
5765 if (jj_3R_358()) {
5766 jj_scanpos = xsp;
5767 if (jj_3R_359()) return true;
5768 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5769 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5770 while (true) {
5771 xsp = jj_scanpos;
5772 if (jj_3R_360()) { jj_scanpos = xsp; break; }
5773 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5774 }
5775 return false;
5776 }
5777
5778 final private boolean jj_3R_421() {
5779 if (jj_scan_token(FINALLY)) return true;
5780 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5781 if (jj_3R_81()) return true;
5782 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5783 return false;
5784 }
5785
5786 final private boolean jj_3R_420() {
5787 if (jj_scan_token(CATCH)) return true;
5788 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5789 if (jj_scan_token(LPAREN)) return true;
5790 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5791 if (jj_3R_371()) return true;
5792 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5793 if (jj_scan_token(RPAREN)) return true;
5794 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5795 if (jj_3R_81()) return true;
5796 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5797 return false;
5798 }
5799
5800 final private boolean jj_3R_241() {
5801 if (jj_scan_token(TRY)) return true;
5802 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5803 if (jj_3R_81()) return true;
5804 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5805 Token xsp;
5806 while (true) {
5807 xsp = jj_scanpos;
5808 if (jj_3R_420()) { jj_scanpos = xsp; break; }
5809 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5810 }
5811 xsp = jj_scanpos;
5812 if (jj_3R_421()) jj_scanpos = xsp;
5813 else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5814 return false;
5815 }
5816
5817 final private boolean jj_3R_80() {
5818 if (jj_scan_token(STATIC)) return true;
5819 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5820 return false;
5821 }
5822
5823 final private boolean jj_3_13() {
5824 if (jj_scan_token(THIS)) return true;
5825 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5826 if (jj_3R_64()) return true;
5827 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5828 if (jj_scan_token(SEMICOLON)) return true;
5829 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5830 return false;
5831 }
5832
5833 final private boolean jj_3R_53() {
5834 Token xsp;
5835 xsp = jj_scanpos;
5836 if (jj_3R_80()) jj_scanpos = xsp;
5837 else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5838 if (jj_3R_81()) return true;
5839 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5840 return false;
5841 }
5842
5843 final private boolean jj_3R_416() {
5844 if (jj_3R_428()) return true;
5845 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5846 return false;
5847 }
5848
5849 final private boolean jj_3R_240() {
5850 if (jj_scan_token(SYNCHRONIZED)) return true;
5851 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5852 if (jj_scan_token(LPAREN)) return true;
5853 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5854 if (jj_3R_70()) return true;
5855 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5856 if (jj_scan_token(RPAREN)) return true;
5857 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5858 if (jj_3R_81()) return true;
5859 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5860 return false;
5861 }
5862
5863 final private boolean jj_3R_419() {
5864 if (jj_3R_70()) return true;
5865 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5866 return false;
5867 }
5868
5869 final private boolean jj_3_12() {
5870 if (jj_3R_63()) return true;
5871 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5872 if (jj_scan_token(DOT)) return true;
5873 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5874 return false;
5875 }
5876
5877 final private boolean jj_3R_418() {
5878 if (jj_scan_token(IDENTIFIER)) return true;
5879 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5880 return false;
5881 }
5882
5883 final private boolean jj_3R_117() {
5884 Token xsp;
5885 xsp = jj_scanpos;
5886 if (jj_3_12()) jj_scanpos = xsp;
5887 else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5888 if (jj_scan_token(SUPER)) return true;
5889 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5890 if (jj_3R_64()) return true;
5891 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5892 if (jj_scan_token(SEMICOLON)) return true;
5893 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5894 return false;
5895 }
5896
5897 final private boolean jj_3R_239() {
5898 if (jj_scan_token(THROW)) return true;
5899 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5900 if (jj_3R_70()) return true;
5901 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5902 if (jj_scan_token(SEMICOLON)) return true;
5903 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5904 return false;
5905 }
5906
5907 final private boolean jj_3_11() {
5908 if (jj_3R_62()) return true;
5909 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5910 return false;
5911 }
5912
5913 final private boolean jj_3R_116() {
5914 if (jj_scan_token(THIS)) return true;
5915 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5916 if (jj_3R_64()) return true;
5917 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5918 if (jj_scan_token(SEMICOLON)) return true;
5919 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5920 return false;
5921 }
5922
5923 final private boolean jj_3R_62() {
5924 Token xsp;
5925 xsp = jj_scanpos;
5926 if (jj_3R_116()) {
5927 jj_scanpos = xsp;
5928 if (jj_3R_117()) return true;
5929 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5930 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5931 return false;
5932 }
5933
5934 final private boolean jj_3R_439() {
5935 if (jj_scan_token(COMMA)) return true;
5936 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5937 if (jj_3R_230()) return true;
5938 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5939 return false;
5940 }
5941
5942 final private boolean jj_3R_238() {
5943 if (jj_scan_token(RETURN)) return true;
5944 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5945 Token xsp;
5946 xsp = jj_scanpos;
5947 if (jj_3R_419()) jj_scanpos = xsp;
5948 else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5949 if (jj_scan_token(SEMICOLON)) return true;
5950 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5951 return false;
5952 }
5953
5954 final private boolean jj_3R_417() {
5955 if (jj_scan_token(IDENTIFIER)) return true;
5956 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5957 return false;
5958 }
5959
5960 final private boolean jj_3R_300() {
5961 if (jj_3R_169()) return true;
5962 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5963 return false;
5964 }
5965
5966 final private boolean jj_3R_299() {
5967 if (jj_3R_62()) return true;
5968 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5969 return false;
5970 }
5971
5972 final private boolean jj_3R_237() {
5973 if (jj_scan_token(CONTINUE)) return true;
5974 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5975 Token xsp;
5976 xsp = jj_scanpos;
5977 if (jj_3R_418()) jj_scanpos = xsp;
5978 else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5979 if (jj_scan_token(SEMICOLON)) return true;
5980 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5981 return false;
5982 }
5983
5984 final private boolean jj_3R_415() {
5985 if (jj_3R_70()) return true;
5986 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5987 return false;
5988 }
5989
5990 final private boolean jj_3R_236() {
5991 if (jj_scan_token(BREAK)) return true;
5992 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5993 Token xsp;
5994 xsp = jj_scanpos;
5995 if (jj_3R_417()) jj_scanpos = xsp;
5996 else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5997 if (jj_scan_token(SEMICOLON)) return true;
5998 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5999 return false;
6000 }
6001
6002 final private boolean jj_3R_337() {
6003 if (jj_scan_token(PRIVATE)) return true;
6004 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6005 return false;
6006 }
6007
6008 final private boolean jj_3R_413() {
6009 if (jj_scan_token(ELSE)) return true;
6010 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6011 if (jj_3R_189()) return true;
6012 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6013 return false;
6014 }
6015
6016 final private boolean jj_3R_428() {
6017 if (jj_3R_438()) return true;
6018 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6019 return false;
6020 }
6021
6022 final private boolean jj_3R_336() {
6023 if (jj_scan_token(PROTECTED)) return true;
6024 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6025 return false;
6026 }
6027
6028 final private boolean jj_3R_372() {
6029 if (jj_scan_token(COMMA)) return true;
6030 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6031 if (jj_3R_371()) return true;
6032 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6033 return false;
6034 }
6035
6036 final private boolean jj_3R_75() {
6037 if (jj_scan_token(FINAL)) return true;
6038 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6039 return false;
6040 }
6041
6042 final private boolean jj_3_31() {
6043 Token xsp;
6044 xsp = jj_scanpos;
6045 if (jj_3R_75()) jj_scanpos = xsp;
6046 else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6047 if (jj_3R_73()) return true;
6048 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6049 if (jj_scan_token(IDENTIFIER)) return true;
6050 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6051 return false;
6052 }
6053
6054 final private boolean jj_3R_438() {
6055 if (jj_3R_230()) return true;
6056 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6057 Token xsp;
6058 while (true) {
6059 xsp = jj_scanpos;
6060 if (jj_3R_439()) { jj_scanpos = xsp; break; }
6061 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6062 }
6063 return false;
6064 }
6065
6066 final private boolean jj_3R_335() {
6067 if (jj_scan_token(PUBLIC)) return true;
6068 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6069 return false;
6070 }
6071
6072 final private boolean jj_3R_296() {
6073 Token xsp;
6074 xsp = jj_scanpos;
6075 if (jj_3R_335()) {
6076 jj_scanpos = xsp;
6077 if (jj_3R_336()) {
6078 jj_scanpos = xsp;
6079 if (jj_3R_337()) return true;
6080 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6081 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6082 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6083 return false;
6084 }
6085
6086 final private boolean jj_3R_282() {
6087 Token xsp;
6088 xsp = jj_scanpos;
6089 if (jj_3R_296()) jj_scanpos = xsp;
6090 else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6091 if (jj_scan_token(IDENTIFIER)) return true;
6092 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6093 if (jj_3R_297()) return true;
6094 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6095 xsp = jj_scanpos;
6096 if (jj_3R_298()) jj_scanpos = xsp;
6097 else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6098 if (jj_scan_token(LBRACE)) return true;
6099 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6100 xsp = jj_scanpos;
6101 if (jj_3R_299()) jj_scanpos = xsp;
6102 else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6103 while (true) {
6104 xsp = jj_scanpos;
6105 if (jj_3R_300()) { jj_scanpos = xsp; break; }
6106 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6107 }
6108 if (jj_scan_token(RBRACE)) return true;
6109 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6110 return false;
6111 }
6112
6113 final private boolean jj_3R_414() {
6114 if (jj_3R_427()) return true;
6115 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6116 return false;
6117 }
6118
6119 final private boolean jj_3R_349() {
6120 if (jj_scan_token(LBRACKET)) return true;
6121 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6122 if (jj_scan_token(RBRACKET)) return true;
6123 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6124 return false;
6125 }
6126
6127 final private boolean jj_3R_437() {
6128 if (jj_3R_438()) return true;
6129 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6130 return false;
6131 }
6132
6133 final private boolean jj_3R_436() {
6134 if (jj_3R_188()) return true;
6135 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6136 return false;
6137 }
6138
6139 final private boolean jj_3R_427() {
6140 Token xsp;
6141 xsp = jj_scanpos;
6142 if (jj_3R_436()) {
6143 jj_scanpos = xsp;
6144 if (jj_3R_437()) return true;
6145 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6146 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6147 return false;
6148 }
6149
6150 final private boolean jj_3R_391() {
6151 if (jj_scan_token(FINAL)) return true;
6152 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6153 return false;
6154 }
6155
6156 final private boolean jj_3R_235() {
6157 if (jj_scan_token(FOR)) return true;
6158 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6159 if (jj_scan_token(LPAREN)) return true;
6160 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6161 Token xsp;
6162 xsp = jj_scanpos;
6163 if (jj_3R_414()) jj_scanpos = xsp;
6164 else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6165 if (jj_scan_token(SEMICOLON)) return true;
6166 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6167 xsp = jj_scanpos;
6168 if (jj_3R_415()) jj_scanpos = xsp;
6169 else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6170 if (jj_scan_token(SEMICOLON)) return true;
6171 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6172 xsp = jj_scanpos;
6173 if (jj_3R_416()) jj_scanpos = xsp;
6174 else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6175 if (jj_scan_token(RPAREN)) return true;
6176 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6177 if (jj_3R_189()) return true;
6178 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6179 return false;
6180 }
6181
6182 final private boolean jj_3R_371() {
6183 Token xsp;
6184 xsp = jj_scanpos;
6185 if (jj_3R_391()) jj_scanpos = xsp;
6186 else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6187 if (jj_3R_392()) return true;
6188 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6189 if (jj_3R_393()) return true;
6190 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6191 return false;
6192 }
6193
6194 final private boolean jj_3R_338() {
6195 if (jj_3R_371()) return true;
6196 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6197 Token xsp;
6198 while (true) {
6199 xsp = jj_scanpos;
6200 if (jj_3R_372()) { jj_scanpos = xsp; break; }
6201 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6202 }
6203 return false;
6204 }
6205
6206 final private boolean jj_3R_234() {
6207 if (jj_scan_token(DO)) return true;
6208 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6209 if (jj_3R_189()) return true;
6210 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6211 if (jj_scan_token(WHILE)) return true;
6212 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6213 if (jj_scan_token(LPAREN)) return true;
6214 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6215 if (jj_3R_70()) return true;
6216 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6217 if (jj_scan_token(RPAREN)) return true;
6218 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6219 if (jj_scan_token(SEMICOLON)) return true;
6220 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6221 return false;
6222 }
6223
6224 final private boolean jj_3R_297() {
6225 if (jj_scan_token(LPAREN)) return true;
6226 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6227 Token xsp;
6228 xsp = jj_scanpos;
6229 if (jj_3R_338()) jj_scanpos = xsp;
6230 else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6231 if (jj_scan_token(RPAREN)) return true;
6232 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6233 return false;
6234 }
6235
6236 final private boolean jj_3R_233() {
6237 if (jj_scan_token(WHILE)) return true;
6238 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6239 if (jj_scan_token(LPAREN)) return true;
6240 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6241 if (jj_3R_70()) return true;
6242 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6243 if (jj_scan_token(RPAREN)) return true;
6244 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6245 if (jj_3R_189()) return true;
6246 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6247 return false;
6248 }
6249
6250 final private boolean jj_3R_426() {
6251 if (jj_3R_169()) return true;
6252 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6253 return false;
6254 }
6255
6256 final private boolean jj_3R_232() {
6257 if (jj_scan_token(IF)) return true;
6258 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6259 if (jj_scan_token(LPAREN)) return true;
6260 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6261 if (jj_3R_70()) return true;
6262 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6263 if (jj_scan_token(RPAREN)) return true;
6264 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6265 if (jj_3R_189()) return true;
6266 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6267 Token xsp;
6268 xsp = jj_scanpos;
6269 if (jj_3R_413()) jj_scanpos = xsp;
6270 else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6271 return false;
6272 }
6273
6274 final private boolean jj_3R_305() {
6275 if (jj_scan_token(SEMICOLON)) return true;
6276 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6277 return false;
6278 }
6279
6280 final private boolean jj_3R_302() {
6281 if (jj_scan_token(IDENTIFIER)) return true;
6282 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6283 if (jj_3R_297()) return true;
6284 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6285 Token xsp;
6286 while (true) {
6287 xsp = jj_scanpos;
6288 if (jj_3R_349()) { jj_scanpos = xsp; break; }
6289 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6290 }
6291 return false;
6292 }
6293
6294 final private boolean jj_3R_435() {
6295 if (jj_scan_token(_DEFAULT)) return true;
6296 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6297 if (jj_scan_token(COLON)) return true;
6298 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6299 return false;
6300 }
6301
6302 final private boolean jj_3R_434() {
6303 if (jj_scan_token(CASE)) return true;
6304 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6305 if (jj_3R_70()) return true;
6306 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6307 if (jj_scan_token(COLON)) return true;
6308 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6309 return false;
6310 }
6311
6312 final private boolean jj_3R_425() {
6313 Token xsp;
6314 xsp = jj_scanpos;
6315 if (jj_3R_434()) {
6316 jj_scanpos = xsp;
6317 if (jj_3R_435()) return true;
6318 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6319 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6320 return false;
6321 }
6322
6323 final private boolean jj_3R_404() {
6324 if (jj_scan_token(COMMA)) return true;
6325 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6326 if (jj_3R_403()) return true;
6327 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6328 return false;
6329 }
6330
6331 final private boolean jj_3R_412() {
6332 if (jj_3R_425()) return true;
6333 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6334 Token xsp;
6335 while (true) {
6336 xsp = jj_scanpos;
6337 if (jj_3R_426()) { jj_scanpos = xsp; break; }
6338 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6339 }
6340 return false;
6341 }
6342
6343 final private boolean jj_3R_304() {
6344 if (jj_3R_350()) return true;
6345 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6346 return false;
6347 }
6348
6349 final private boolean jj_3R_303() {
6350 if (jj_scan_token(THROWS)) return true;
6351 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6352 if (jj_3R_339()) return true;
6353 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6354 return false;
6355 }
6356
6357 final private boolean jj_3R_231() {
6358 if (jj_scan_token(SWITCH)) return true;
6359 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6360 if (jj_scan_token(LPAREN)) return true;
6361 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6362 if (jj_3R_70()) return true;
6363 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6364 if (jj_scan_token(RPAREN)) return true;
6365 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6366 if (jj_scan_token(LBRACE)) return true;
6367 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6368 Token xsp;
6369 while (true) {
6370 xsp = jj_scanpos;
6371 if (jj_3R_412()) { jj_scanpos = xsp; break; }
6372 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6373 }
6374 if (jj_scan_token(RBRACE)) return true;
6375 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6376 return false;
6377 }
6378
6379 final private boolean jj_3R_264() {
6380 if (jj_scan_token(COMMA)) return true;
6381 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6382 return false;
6383 }
6384
6385 final private boolean jj_3R_433() {
6386 if (jj_3R_195()) return true;
6387 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6388 if (jj_3R_70()) return true;
6389 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6390 return false;
6391 }
6392
6393 final private boolean jj_3R_432() {
6394 if (jj_scan_token(DECR)) return true;
6395 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6396 return false;
6397 }
6398
6399 final private boolean jj_3R_348() {
6400 if (jj_scan_token(STRICTFP)) return true;
6401 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6402 return false;
6403 }
6404
6405 final private boolean jj_3R_431() {
6406 if (jj_scan_token(INCR)) return true;
6407 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6408 return false;
6409 }
6410
6411 final private boolean jj_3R_424() {
6412 Token xsp;
6413 xsp = jj_scanpos;
6414 if (jj_3R_431()) {
6415 jj_scanpos = xsp;
6416 if (jj_3R_432()) {
6417 jj_scanpos = xsp;
6418 if (jj_3R_433()) return true;
6419 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6420 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6421 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6422 return false;
6423 }
6424
6425 final private boolean jj_3R_247() {
6426 if (jj_3R_63()) return true;
6427 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6428 Token xsp;
6429 xsp = jj_scanpos;
6430 if (jj_3R_424()) jj_scanpos = xsp;
6431 else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6432 return false;
6433 }
6434
6435 final private boolean jj_3R_347() {
6436 if (jj_scan_token(SYNCHRONIZED)) return true;
6437 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6438 return false;
6439 }
6440
6441 final private boolean jj_3R_246() {
6442 if (jj_3R_254()) return true;
6443 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6444 return false;
6445 }
6446
6447 final private boolean jj_3R_230() {
6448 Token xsp;
6449 xsp = jj_scanpos;
6450 if (jj_3R_245()) {
6451 jj_scanpos = xsp;
6452 if (jj_3R_246()) {
6453 jj_scanpos = xsp;
6454 if (jj_3R_247()) return true;
6455 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6456 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6457 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6458 return false;
6459 }
6460
6461 final private boolean jj_3R_245() {
6462 if (jj_3R_253()) return true;
6463 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6464 return false;
6465 }
6466
6467 final private boolean jj_3R_346() {
6468 if (jj_scan_token(NATIVE)) return true;
6469 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6470 return false;
6471 }
6472
6473 final private boolean jj_3R_345() {
6474 if (jj_scan_token(FINAL)) return true;
6475 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6476 return false;
6477 }
6478
6479 final private boolean jj_3R_229() {
6480 if (jj_scan_token(SEMICOLON)) return true;
6481 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6482 return false;
6483 }
6484
6485 final private boolean jj_3R_344() {
6486 if (jj_scan_token(ABSTRACT)) return true;
6487 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6488 return false;
6489 }
6490
6491 final private boolean jj_3R_197() {
6492 if (jj_scan_token(FINAL)) return true;
6493 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6494 return false;
6495 }
6496
6497 final private boolean jj_3R_188() {
6498 Token xsp;
6499 xsp = jj_scanpos;
6500 if (jj_3R_197()) jj_scanpos = xsp;
6501 else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6502 if (jj_3R_73()) return true;
6503 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6504 if (jj_3R_403()) return true;
6505 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6506 while (true) {
6507 xsp = jj_scanpos;
6508 if (jj_3R_404()) { jj_scanpos = xsp; break; }
6509 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6510 }
6511 return false;
6512 }
6513
6514 final private boolean jj_3R_343() {
6515 if (jj_scan_token(STATIC)) return true;
6516 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6517 return false;
6518 }
6519
6520 final private boolean jj_3R_342() {
6521 if (jj_scan_token(PRIVATE)) return true;
6522 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6523 return false;
6524 }
6525
6526 final private boolean jj_3R_408() {
6527 if (jj_3R_191()) return true;
6528 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6529 return false;
6530 }
6531
6532 final private boolean jj_3_10() {
6533 if (jj_scan_token(COMMA)) return true;
6534 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6535 if (jj_3R_61()) return true;
6536 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6537 return false;
6538 }
6539
6540 final private boolean jj_3R_74() {
6541 if (jj_scan_token(FINAL)) return true;
6542 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6543 return false;
6544 }
6545
6546 final private boolean jj_3_30() {
6547 Token xsp;
6548 xsp = jj_scanpos;
6549 if (jj_3R_74()) jj_scanpos = xsp;
6550 else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6551 if (jj_3R_73()) return true;
6552 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6553 if (jj_scan_token(IDENTIFIER)) return true;
6554 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6555 return false;
6556 }
6557
6558 final private boolean jj_3R_341() {
6559 if (jj_scan_token(PROTECTED)) return true;
6560 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6561 return false;
6562 }
6563
6564 final private boolean jj_3R_407() {
6565 if (jj_3R_190()) return true;
6566 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6567 return false;
6568 }
6569
6570 final private boolean jj_3R_406() {
6571 if (jj_3R_189()) return true;
6572 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6573 return false;
6574 }
6575
6576 final private boolean jj_3R_340() {
6577 if (jj_scan_token(PUBLIC)) return true;
6578 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6579 return false;
6580 }
6581
6582 final private boolean jj_3R_301() {
6583 Token xsp;
6584 xsp = jj_scanpos;
6585 if (jj_3R_340()) {
6586 jj_scanpos = xsp;
6587 if (jj_3R_341()) {
6588 jj_scanpos = xsp;
6589 if (jj_3R_342()) {
6590 jj_scanpos = xsp;
6591 if (jj_3R_343()) {
6592 jj_scanpos = xsp;
6593 if (jj_3R_344()) {
6594 jj_scanpos = xsp;
6595 if (jj_3R_345()) {
6596 jj_scanpos = xsp;
6597 if (jj_3R_346()) {
6598 jj_scanpos = xsp;
6599 if (jj_3R_347()) {
6600 jj_scanpos = xsp;
6601 if (jj_3R_348()) return true;
6602 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6603 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6604 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6605 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6606 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6607 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6608 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6609 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6610 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6611 return false;
6612 }
6613
6614 final private boolean jj_3R_405() {
6615 if (jj_3R_188()) return true;
6616 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6617 if (jj_scan_token(SEMICOLON)) return true;
6618 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6619 return false;
6620 }
6621
6622 final private boolean jj_3R_395() {
6623 Token xsp;
6624 xsp = jj_scanpos;
6625 if (jj_3R_405()) {
6626 jj_scanpos = xsp;
6627 if (jj_3R_406()) {
6628 jj_scanpos = xsp;
6629 if (jj_3R_407()) {
6630 jj_scanpos = xsp;
6631 if (jj_3R_408()) return true;
6632 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6633 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6634 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6635 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6636 return false;
6637 }
6638
6639 final private boolean jj_3R_283() {
6640 Token xsp;
6641 while (true) {
6642 xsp = jj_scanpos;
6643 if (jj_3R_301()) { jj_scanpos = xsp; break; }
6644 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6645 }
6646 if (jj_3R_68()) return true;
6647 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6648 if (jj_3R_302()) return true;
6649 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6650 xsp = jj_scanpos;
6651 if (jj_3R_303()) jj_scanpos = xsp;
6652 else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6653 xsp = jj_scanpos;
6654 if (jj_3R_304()) {
6655 jj_scanpos = xsp;
6656 if (jj_3R_305()) return true;
6657 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6658 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6659 return false;
6660 }
6661
6662 final private boolean jj_3R_263() {
6663 if (jj_3R_61()) return true;
6664 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6665 Token xsp;
6666 while (true) {
6667 xsp = jj_scanpos;
6668 if (jj_3_10()) { jj_scanpos = xsp; break; }
6669 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6670 }
6671 return false;
6672 }
6673
6674 final private boolean jj_3R_179() {
6675 if (jj_3R_191()) return true;
6676 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6677 return false;
6678 }
6679
6680 final private boolean jj_3R_72() {
6681 if (jj_scan_token(FINAL)) return true;
6682 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6683 return false;
6684 }
6685
6686 final private boolean jj_3_29() {
6687 Token xsp;
6688 xsp = jj_scanpos;
6689 if (jj_3R_72()) jj_scanpos = xsp;
6690 else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6691 if (jj_3R_73()) return true;
6692 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6693 if (jj_scan_token(IDENTIFIER)) return true;
6694 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6695 return false;
6696 }
6697
6698 final private boolean jj_3R_411() {
6699 if (jj_scan_token(LBRACKET)) return true;
6700 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6701 if (jj_scan_token(RBRACKET)) return true;
6702 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6703 return false;
6704 }
6705
6706 final private boolean jj_3R_150() {
6707 if (jj_scan_token(LBRACE)) return true;
6708 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6709 Token xsp;
6710 xsp = jj_scanpos;
6711 if (jj_3R_263()) jj_scanpos = xsp;
6712 else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6713 xsp = jj_scanpos;
6714 if (jj_3R_264()) jj_scanpos = xsp;
6715 else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6716 if (jj_scan_token(RBRACE)) return true;
6717 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6718 return false;
6719 }
6720
6721 final private boolean jj_3R_178() {
6722 if (jj_3R_190()) return true;
6723 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6724 return false;
6725 }
6726
6727 final private boolean jj_3R_177() {
6728 if (jj_3R_189()) return true;
6729 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6730 return false;
6731 }
6732
6733 final private boolean jj_3R_402() {
6734 if (jj_scan_token(LBRACKET)) return true;
6735 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6736 if (jj_scan_token(RBRACKET)) return true;
6737 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6738 return false;
6739 }
6740
6741 final private boolean jj_3R_115() {
6742 if (jj_3R_70()) return true;
6743 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6744 return false;
6745 }
6746
6747 final private boolean jj_3R_362() {
6748 if (jj_scan_token(ASSIGN)) return true;
6749 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6750 if (jj_3R_61()) return true;
6751 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6752 return false;
6753 }
6754
6755 final private boolean jj_3R_114() {
6756 if (jj_3R_150()) return true;
6757 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6758 return false;
6759 }
6760
6761 final private boolean jj_3R_61() {
6762 Token xsp;
6763 xsp = jj_scanpos;
6764 if (jj_3R_114()) {
6765 jj_scanpos = xsp;
6766 if (jj_3R_115()) return true;
6767 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6768 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6769 return false;
6770 }
6771
6772 final private boolean jj_3R_169() {
6773 Token xsp;
6774 xsp = jj_scanpos;
6775 if (jj_3R_176()) {
6776 jj_scanpos = xsp;
6777 if (jj_3R_177()) {
6778 jj_scanpos = xsp;
6779 if (jj_3R_178()) {
6780 jj_scanpos = xsp;
6781 if (jj_3R_179()) return true;
6782 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6783 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6784 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6785 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6786 return false;
6787 }
6788
6789 final private boolean jj_3R_176() {
6790 if (jj_3R_188()) return true;
6791 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6792 if (jj_scan_token(SEMICOLON)) return true;
6793 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6794 return false;
6795 }
6796
6797 final private boolean jj_3R_409() {
6798 if (jj_scan_token(IDENTIFIER)) return true;
6799 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6800 Token xsp;
6801 while (true) {
6802 xsp = jj_scanpos;
6803 if (jj_3R_411()) { jj_scanpos = xsp; break; }
6804 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6805 }
6806 return false;
6807 }
6808
6809 final private boolean jj_3R_376() {
6810 if (jj_scan_token(SEMICOLON)) return true;
6811 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6812 return false;
6813 }
6814
6815 final private boolean jj_3R_410() {
6816 if (jj_scan_token(ASSIGN)) return true;
6817 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6818 if (jj_3R_61()) return true;
6819 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6820 return false;
6821 }
6822
6823 final private boolean jj_3R_377() {
6824 if (jj_scan_token(LBRACKET)) return true;
6825 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6826 if (jj_scan_token(RBRACKET)) return true;
6827 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6828 return false;
6829 }
6830
6831 final private boolean jj_3R_375() {
6832 if (jj_3R_395()) return true;
6833 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6834 return false;
6835 }
6836
6837 final private boolean jj_3R_393() {
6838 if (jj_scan_token(IDENTIFIER)) return true;
6839 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6840 Token xsp;
6841 while (true) {
6842 xsp = jj_scanpos;
6843 if (jj_3R_402()) { jj_scanpos = xsp; break; }
6844 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6845 }
6846 return false;
6847 }
6848
6849 final private boolean jj_3R_350() {
6850 if (jj_scan_token(LBRACE)) return true;
6851 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6852 Token xsp;
6853 while (true) {
6854 xsp = jj_scanpos;
6855 if (jj_3R_375()) { jj_scanpos = xsp; break; }
6856 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6857 }
6858 if (jj_scan_token(RBRACE)) return true;
6859 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6860 xsp = jj_scanpos;
6861 if (jj_3R_376()) jj_scanpos = xsp;
6862 else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6863 return false;
6864 }
6865
6866 final private boolean jj_3R_140() {
6867 if (jj_3R_169()) return true;
6868 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6869 return false;
6870 }
6871
6872 final private boolean jj_3R_81() {
6873 if (jj_scan_token(LBRACE)) return true;
6874 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6875 Token xsp;
6876 while (true) {
6877 xsp = jj_scanpos;
6878 if (jj_3R_140()) { jj_scanpos = xsp; break; }
6879 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6880 }
6881 if (jj_scan_token(RBRACE)) return true;
6882 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6883 return false;
6884 }
6885
6886 final private boolean jj_3R_361() {
6887 if (jj_scan_token(IDENTIFIER)) return true;
6888 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6889 Token xsp;
6890 while (true) {
6891 xsp = jj_scanpos;
6892 if (jj_3R_377()) { jj_scanpos = xsp; break; }
6893 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6894 }
6895 return false;
6896 }
6897
6898 final private boolean jj_3R_71() {
6899 if (jj_scan_token(IDENTIFIER)) return true;
6900 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6901 if (jj_scan_token(COLON)) return true;
6902 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6903 if (jj_3R_189()) return true;
6904 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6905 return false;
6906 }
6907
6908 final private boolean jj_3R_212() {
6909 if (jj_3R_242()) return true;
6910 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6911 return false;
6912 }
6913
6914 final private boolean jj_3R_403() {
6915 if (jj_3R_409()) return true;
6916 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6917 Token xsp;
6918 xsp = jj_scanpos;
6919 if (jj_3R_410()) jj_scanpos = xsp;
6920 else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6921 return false;
6922 }
6923
6924 final private boolean jj_3R_113() {
6925 if (jj_scan_token(STRICTFP)) return true;
6926 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6927 return false;
6928 }
6929
6930 final private boolean jj_3R_211() {
6931 if (jj_3R_241()) return true;
6932 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6933 return false;
6934 }
6935
6936 final private boolean jj_3_26() {
6937 if (jj_scan_token(LBRACKET)) return true;
6938 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6939 if (jj_scan_token(RBRACKET)) return true;
6940 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6941 return false;
6942 }
6943
6944 final private boolean jj_3R_106() {
6945 if (jj_scan_token(STRICTFP)) return true;
6946 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6947 return false;
6948 }
6949
6950 final private boolean jj_3R_210() {
6951 if (jj_3R_240()) return true;
6952 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6953 return false;
6954 }
6955
6956 final private boolean jj_3R_209() {
6957 if (jj_3R_239()) return true;
6958 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6959 return false;
6960 }
6961
6962 final private boolean jj_3R_308() {
6963 if (jj_3R_361()) return true;
6964 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6965 Token xsp;
6966 xsp = jj_scanpos;
6967 if (jj_3R_362()) jj_scanpos = xsp;
6968 else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6969 return false;
6970 }
6971
6972 final private boolean jj_3R_208() {
6973 if (jj_3R_238()) return true;
6974 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6975 return false;
6976 }
6977
6978 final private boolean jj_3R_207() {
6979 if (jj_3R_237()) return true;
6980 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6981 return false;
6982 }
6983
6984 final private boolean jj_3R_206() {
6985 if (jj_3R_236()) return true;
6986 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6987 return false;
6988 }
6989
6990 final private boolean jj_3R_112() {
6991 if (jj_scan_token(PRIVATE)) return true;
6992 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6993 return false;
6994 }
6995
6996 final private boolean jj_3R_205() {
6997 if (jj_3R_235()) return true;
6998 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6999 return false;
7000 }
7001
7002 final private boolean jj_3R_105() {
7003 if (jj_scan_token(PRIVATE)) return true;
7004 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7005 return false;
7006 }
7007
7008 final private boolean jj_3R_204() {
7009 if (jj_3R_234()) return true;
7010 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7011 return false;
7012 }
7013
7014 final private boolean jj_3R_203() {
7015 if (jj_3R_233()) return true;
7016 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7017 return false;
7018 }
7019
7020 final private boolean jj_3R_202() {
7021 if (jj_3R_232()) return true;
7022 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7023 return false;
7024 }
7025
7026 final private boolean jj_3R_201() {
7027 if (jj_3R_231()) return true;
7028 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7029 return false;
7030 }
7031
7032 final private boolean jj_3R_200() {
7033 if (jj_3R_230()) return true;
7034 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7035 if (jj_scan_token(SEMICOLON)) return true;
7036 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7037 return false;
7038 }
7039
7040 final private boolean jj_3R_309() {
7041 if (jj_scan_token(COMMA)) return true;
7042 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7043 if (jj_3R_308()) return true;
7044 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7045 return false;
7046 }
7047
7048 final private boolean jj_3R_199() {
7049 if (jj_3R_229()) return true;
7050 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7051 return false;
7052 }
7053
7054 final private boolean jj_3R_111() {
7055 if (jj_scan_token(PROTECTED)) return true;
7056 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7057 return false;
7058 }
7059
7060 final private boolean jj_3R_198() {
7061 if (jj_3R_81()) return true;
7062 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7063 return false;
7064 }
7065
7066 final private boolean jj_3R_104() {
7067 if (jj_scan_token(PROTECTED)) return true;
7068 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7069 return false;
7070 }
7071
7072 final private boolean jj_3_28() {
7073 if (jj_3R_71()) return true;
7074 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7075 return false;
7076 }
7077
7078 final private boolean jj_3R_189() {
7079 Token xsp;
7080 xsp = jj_scanpos;
7081 if (jj_3_28()) {
7082 jj_scanpos = xsp;
7083 if (jj_3R_198()) {
7084 jj_scanpos = xsp;
7085 if (jj_3R_199()) {
7086 jj_scanpos = xsp;
7087 if (jj_3R_200()) {
7088 jj_scanpos = xsp;
7089 if (jj_3R_201()) {
7090 jj_scanpos = xsp;
7091 if (jj_3R_202()) {
7092 jj_scanpos = xsp;
7093 if (jj_3R_203()) {
7094 jj_scanpos = xsp;
7095 if (jj_3R_204()) {
7096 jj_scanpos = xsp;
7097 if (jj_3R_205()) {
7098 jj_scanpos = xsp;
7099 if (jj_3R_206()) {
7100 jj_scanpos = xsp;
7101 if (jj_3R_207()) {
7102 jj_scanpos = xsp;
7103 if (jj_3R_208()) {
7104 jj_scanpos = xsp;
7105 if (jj_3R_209()) {
7106 jj_scanpos = xsp;
7107 if (jj_3R_210()) {
7108 jj_scanpos = xsp;
7109 if (jj_3R_211()) {
7110 jj_scanpos = xsp;
7111 if (jj_3R_212()) 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 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7115 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7116 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7117 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7118 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7119 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7120 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7121 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7122 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7123 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7124 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7125 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7126 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7127 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7128 return false;
7129 }
7130
7131 final private boolean jj_3R_357() {
7132 if (jj_scan_token(VOLATILE)) return true;
7133 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7134 return false;
7135 }
7136
7137 final private boolean jj_3R_356() {
7138 if (jj_scan_token(TRANSIENT)) return true;
7139 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7140 return false;
7141 }
7142
7143 final private boolean jj_3R_110() {
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_259() {
7150 if (jj_scan_token(LBRACKET)) return true;
7151 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7152 if (jj_scan_token(RBRACKET)) return true;
7153 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7154 return false;
7155 }
7156
7157 final private boolean jj_3R_355() {
7158 if (jj_scan_token(FINAL)) return true;
7159 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7160 return false;
7161 }
7162
7163 final private boolean jj_3R_103() {
7164 if (jj_scan_token(PUBLIC)) return true;
7165 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7166 return false;
7167 }
7168
7169 final private boolean jj_3_25() {
7170 if (jj_scan_token(LBRACKET)) return true;
7171 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7172 if (jj_3R_70()) return true;
7173 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7174 if (jj_scan_token(RBRACKET)) return true;
7175 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7176 return false;
7177 }
7178
7179 final private boolean jj_3R_255() {
7180 Token xsp;
7181 if (jj_3R_259()) return true;
7182 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7183 while (true) {
7184 xsp = jj_scanpos;
7185 if (jj_3R_259()) { jj_scanpos = xsp; break; }
7186 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7187 }
7188 if (jj_3R_150()) return true;
7189 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7190 return false;
7191 }
7192
7193 final private boolean jj_3R_354() {
7194 if (jj_scan_token(STATIC)) return true;
7195 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7196 return false;
7197 }
7198
7199 final private boolean jj_3_27() {
7200 Token xsp;
7201 if (jj_3_25()) return true;
7202 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7203 while (true) {
7204 xsp = jj_scanpos;
7205 if (jj_3_25()) { jj_scanpos = xsp; break; }
7206 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7207 }
7208 while (true) {
7209 xsp = jj_scanpos;
7210 if (jj_3_26()) { jj_scanpos = xsp; break; }
7211 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7212 }
7213 return false;
7214 }
7215
7216 final private boolean jj_3R_248() {
7217 Token xsp;
7218 xsp = jj_scanpos;
7219 if (jj_3_27()) {
7220 jj_scanpos = xsp;
7221 if (jj_3R_255()) return true;
7222 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7223 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7224 return false;
7225 }
7226
7227 final private boolean jj_3R_109() {
7228 if (jj_scan_token(FINAL)) return true;
7229 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7230 return false;
7231 }
7232
7233 final private boolean jj_3R_353() {
7234 if (jj_scan_token(PRIVATE)) return true;
7235 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7236 return false;
7237 }
7238
7239 final private boolean jj_3R_102() {
7240 if (jj_scan_token(FINAL)) return true;
7241 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7242 return false;
7243 }
7244
7245 final private boolean jj_3R_352() {
7246 if (jj_scan_token(PROTECTED)) return true;
7247 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7248 return false;
7249 }
7250
7251 final private boolean jj_3R_351() {
7252 if (jj_scan_token(PUBLIC)) return true;
7253 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7254 return false;
7255 }
7256
7257 final private boolean jj_3R_306() {
7258 Token xsp;
7259 xsp = jj_scanpos;
7260 if (jj_3R_351()) {
7261 jj_scanpos = xsp;
7262 if (jj_3R_352()) {
7263 jj_scanpos = xsp;
7264 if (jj_3R_353()) {
7265 jj_scanpos = xsp;
7266 if (jj_3R_354()) {
7267 jj_scanpos = xsp;
7268 if (jj_3R_355()) {
7269 jj_scanpos = xsp;
7270 if (jj_3R_356()) {
7271 jj_scanpos = xsp;
7272 if (jj_3R_357()) return true;
7273 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7274 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7275 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7276 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7277 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7278 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7279 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7280 return false;
7281 }
7282
7283 final private boolean jj_3R_284() {
7284 Token xsp;
7285 while (true) {
7286 xsp = jj_scanpos;
7287 if (jj_3R_306()) { jj_scanpos = xsp; break; }
7288 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7289 }
7290 if (jj_3R_307()) return true;
7291 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7292 if (jj_3R_308()) return true;
7293 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7294 while (true) {
7295 xsp = jj_scanpos;
7296 if (jj_3R_309()) { jj_scanpos = xsp; break; }
7297 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7298 }
7299 if (jj_scan_token(SEMICOLON)) return true;
7300 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7301 return false;
7302 }
7303
7304 final private boolean jj_3R_108() {
7305 if (jj_scan_token(ABSTRACT)) return true;
7306 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7307 return false;
7308 }
7309
7310 final private boolean jj_3R_101() {
7311 if (jj_scan_token(ABSTRACT)) return true;
7312 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7313 return false;
7314 }
7315
7316 final private boolean jj_3R_256() {
7317 if (jj_3R_260()) return true;
7318 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7319 return false;
7320 }
7321
7322 final private boolean jj_3R_250() {
7323 if (jj_3R_64()) return true;
7324 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7325 Token xsp;
7326 xsp = jj_scanpos;
7327 if (jj_3R_256()) jj_scanpos = xsp;
7328 else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7329 return false;
7330 }
7331
7332 final private boolean jj_3R_249() {
7333 if (jj_3R_248()) return true;
7334 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7335 return false;
7336 }
7337
7338 final private boolean jj_3_9() {
7339 if (jj_3R_58()) return true;
7340 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7341 return false;
7342 }
7343
7344 final private boolean jj_3R_107() {
7345 if (jj_scan_token(STATIC)) return true;
7346 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7347 return false;
7348 }
7349
7350 final private boolean jj_3R_60() {
7351 Token xsp;
7352 xsp = jj_scanpos;
7353 if (jj_3R_107()) {
7354 jj_scanpos = xsp;
7355 if (jj_3R_108()) {
7356 jj_scanpos = xsp;
7357 if (jj_3R_109()) {
7358 jj_scanpos = xsp;
7359 if (jj_3R_110()) {
7360 jj_scanpos = xsp;
7361 if (jj_3R_111()) {
7362 jj_scanpos = xsp;
7363 if (jj_3R_112()) {
7364 jj_scanpos = xsp;
7365 if (jj_3R_113()) return true;
7366 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7367 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7368 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7369 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7370 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7371 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7372 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7373 return false;
7374 }
7375
7376 final private boolean jj_3_8() {
7377 Token xsp;
7378 while (true) {
7379 xsp = jj_scanpos;
7380 if (jj_3R_60()) { jj_scanpos = xsp; break; }
7381 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7382 }
7383 if (jj_scan_token(INTERFACE)) return true;
7384 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7385 return false;
7386 }
7387
7388 final private boolean jj_3R_171() {
7389 if (jj_scan_token(COMMA)) return true;
7390 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7391 if (jj_3R_70()) return true;
7392 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7393 return false;
7394 }
7395
7396 final private boolean jj_3R_100() {
7397 if (jj_scan_token(STATIC)) return true;
7398 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7399 return false;
7400 }
7401
7402 final private boolean jj_3R_59() {
7403 Token xsp;
7404 xsp = jj_scanpos;
7405 if (jj_3R_100()) {
7406 jj_scanpos = xsp;
7407 if (jj_3R_101()) {
7408 jj_scanpos = xsp;
7409 if (jj_3R_102()) {
7410 jj_scanpos = xsp;
7411 if (jj_3R_103()) {
7412 jj_scanpos = xsp;
7413 if (jj_3R_104()) {
7414 jj_scanpos = xsp;
7415 if (jj_3R_105()) {
7416 jj_scanpos = xsp;
7417 if (jj_3R_106()) return true;
7418 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7419 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7420 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7421 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7422 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7423 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7424 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7425 return false;
7426 }
7427
7428 final private boolean jj_3R_135() {
7429 if (jj_scan_token(NEW)) return true;
7430 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7431 if (jj_3R_57()) return true;
7432 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7433 Token xsp;
7434 xsp = jj_scanpos;
7435 if (jj_3R_249()) {
7436 jj_scanpos = xsp;
7437 if (jj_3R_250()) return true;
7438 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7439 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7440 return false;
7441 }
7442
7443 final private boolean jj_3_7() {
7444 Token xsp;
7445 while (true) {
7446 xsp = jj_scanpos;
7447 if (jj_3R_59()) { jj_scanpos = xsp; break; }
7448 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7449 }
7450 if (jj_scan_token(CLASS)) return true;
7451 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7452 return false;
7453 }
7454
7455 final private boolean jj_3_24() {
7456 if (jj_scan_token(NEW)) return true;
7457 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7458 if (jj_3R_66()) return true;
7459 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7460 if (jj_3R_248()) return true;
7461 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7462 return false;
7463 }
7464
7465 final private boolean jj_3R_69() {
7466 Token xsp;
7467 xsp = jj_scanpos;
7468 if (jj_3_24()) {
7469 jj_scanpos = xsp;
7470 if (jj_3R_135()) return true;
7471 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7472 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7473 return false;
7474 }
7475
7476 final private boolean jj_3R_390() {
7477 if (jj_3R_284()) return true;
7478 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7479 return false;
7480 }
7481
7482 final private boolean jj_3R_389() {
7483 if (jj_3R_283()) return true;
7484 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7485 return false;
7486 }
7487
7488 final private boolean jj_3R_388() {
7489 if (jj_3R_281()) return true;
7490 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7491 return false;
7492 }
7493
7494 final private boolean jj_3R_387() {
7495 if (jj_3R_280()) return true;
7496 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7497 return false;
7498 }
7499
7500 final private boolean jj_3R_370() {
7501 Token xsp;
7502 xsp = jj_scanpos;
7503 if (jj_3R_387()) {
7504 jj_scanpos = xsp;
7505 if (jj_3R_388()) {
7506 jj_scanpos = xsp;
7507 if (jj_3R_389()) {
7508 jj_scanpos = xsp;
7509 if (jj_3R_390()) return true;
7510 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7511 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7512 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7513 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7514 return false;
7515 }
7516
7517 final private boolean jj_3R_158() {
7518 if (jj_3R_70()) return true;
7519 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7520 Token xsp;
7521 while (true) {
7522 xsp = jj_scanpos;
7523 if (jj_3R_171()) { jj_scanpos = xsp; break; }
7524 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7525 }
7526 return false;
7527 }
7528
7529 final private boolean jj_3R_119() {
7530 if (jj_3R_158()) return true;
7531 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7532 return false;
7533 }
7534
7535 final private boolean jj_3R_64() {
7536 if (jj_scan_token(LPAREN)) return true;
7537 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7538 Token xsp;
7539 xsp = jj_scanpos;
7540 if (jj_3R_119()) jj_scanpos = xsp;
7541 else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7542 if (jj_scan_token(RPAREN)) return true;
7543 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7544 return false;
7545 }
7546
7547 final private boolean jj_3R_334() {
7548 if (jj_3R_370()) return true;
7549 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7550 return false;
7551 }
7552
7553 final private boolean jj_3R_193() {
7554 if (jj_scan_token(NULL)) return true;
7555 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7556 return false;
7557 }
7558
7559 final private boolean jj_3R_333() {
7560 if (jj_scan_token(EXTENDS)) return true;
7561 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7562 if (jj_3R_369()) return true;
7563 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7564 return false;
7565 }
7566
7567 final private boolean jj_3R_149() {
7568 if (jj_scan_token(STRICTFP)) return true;
7569 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7570 return false;
7571 }
7572
7573 final private boolean jj_3R_214() {
7574 if (jj_scan_token(FALSE)) return true;
7575 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7576 return false;
7577 }
7578
7579 final private boolean jj_3R_192() {
7580 Token xsp;
7581 xsp = jj_scanpos;
7582 if (jj_3R_213()) {
7583 jj_scanpos = xsp;
7584 if (jj_3R_214()) return true;
7585 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7586 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7587 return false;
7588 }
7589
7590 final private boolean jj_3R_213() {
7591 if (jj_scan_token(TRUE)) return true;
7592 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7593 return false;
7594 }
7595
7596 final private boolean jj_3R_166() {
7597 if (jj_3R_170()) return true;
7598 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7599 return false;
7600 }
7601
7602 final private boolean jj_3R_185() {
7603 if (jj_3R_193()) return true;
7604 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7605 return false;
7606 }
7607
7608 final private boolean jj_3R_184() {
7609 if (jj_3R_192()) return true;
7610 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7611 return false;
7612 }
7613
7614 final private boolean jj_3R_183() {
7615 if (jj_scan_token(STRING_LITERAL)) return true;
7616 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7617 return false;
7618 }
7619
7620 final private boolean jj_3R_148() {
7621 if (jj_scan_token(SYNCHRONIZED)) return true;
7622 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7623 return false;
7624 }
7625
7626 final private boolean jj_3R_182() {
7627 if (jj_scan_token(CHARACTER_LITERAL)) return true;
7628 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7629 return false;
7630 }
7631
7632 final private boolean jj_3R_165() {
7633 if (jj_scan_token(NEW)) return true;
7634 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7635 return false;
7636 }
7637
7638 final private boolean jj_3R_181() {
7639 if (jj_scan_token(FLOATING_POINT_LITERAL)) return true;
7640 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7641 return false;
7642 }
7643
7644 final private boolean jj_3R_191() {
7645 if (jj_scan_token(INTERFACE)) return true;
7646 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7647 if (jj_scan_token(IDENTIFIER)) return true;
7648 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7649 Token xsp;
7650 xsp = jj_scanpos;
7651 if (jj_3R_333()) jj_scanpos = xsp;
7652 else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7653 if (jj_scan_token(LBRACE)) return true;
7654 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7655 while (true) {
7656 xsp = jj_scanpos;
7657 if (jj_3R_334()) { jj_scanpos = xsp; break; }
7658 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7659 }
7660 if (jj_scan_token(RBRACE)) return true;
7661 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7662 return false;
7663 }
7664
7665 public SimpleParserTokenManager token_source;
7666 JavaCharStream jj_input_stream;
7667 public Token token, jj_nt;
7668 private Token jj_scanpos, jj_lastpos;
7669 private int jj_la;
7670 public boolean lookingAhead = false;
7671 private boolean jj_semLA;
7672 private int jj_gen;
7673 final private int[] jj_la1 = new int[129];
7674 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,};
7675 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,};
7676 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,};
7677 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,};
7678 final private JJCalls[] jj_2_rtns = new JJCalls[31];
7679 private boolean jj_rescan = false;
7680 private int jj_gc = 0;
7681
7682 public SimpleParser(java.io.InputStream stream) {
7683 jj_input_stream = new JavaCharStream(stream, 1, 1);
7684 token_source = new SimpleParserTokenManager(jj_input_stream);
7685 token = new Token();
7686 token.next = jj_nt = token_source.getNextToken();
7687 jj_gen = 0;
7688 for (int i = 0; i < 129; i++) jj_la1[i] = -1;
7689 for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
7690 }
7691
7692 public void ReInit(java.io.InputStream stream) {
7693 jj_input_stream.ReInit(stream, 1, 1);
7694 token_source.ReInit(jj_input_stream);
7695 token = new Token();
7696 token.next = jj_nt = token_source.getNextToken();
7697 jj_gen = 0;
7698 for (int i = 0; i < 129; i++) jj_la1[i] = -1;
7699 for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
7700 }
7701
7702 public SimpleParser(java.io.Reader stream) {
7703 jj_input_stream = new JavaCharStream(stream, 1, 1);
7704 token_source = new SimpleParserTokenManager(jj_input_stream);
7705 token = new Token();
7706 token.next = jj_nt = token_source.getNextToken();
7707 jj_gen = 0;
7708 for (int i = 0; i < 129; i++) jj_la1[i] = -1;
7709 for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
7710 }
7711
7712 public void ReInit(java.io.Reader stream) {
7713 jj_input_stream.ReInit(stream, 1, 1);
7714 token_source.ReInit(jj_input_stream);
7715 token = new Token();
7716 token.next = jj_nt = token_source.getNextToken();
7717 jj_gen = 0;
7718 for (int i = 0; i < 129; i++) jj_la1[i] = -1;
7719 for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
7720 }
7721
7722 public SimpleParser(SimpleParserTokenManager tm) {
7723 token_source = tm;
7724 token = new Token();
7725 token.next = jj_nt = token_source.getNextToken();
7726 jj_gen = 0;
7727 for (int i = 0; i < 129; i++) jj_la1[i] = -1;
7728 for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
7729 }
7730
7731 public void ReInit(SimpleParserTokenManager tm) {
7732 token_source = tm;
7733 token = new Token();
7734 token.next = jj_nt = token_source.getNextToken();
7735 jj_gen = 0;
7736 for (int i = 0; i < 129; i++) jj_la1[i] = -1;
7737 for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
7738 }
7739
7740 final private Token jj_consume_token(int kind) throws ParseException {
7741 Token oldToken = token;
7742 if ((token = jj_nt).next != null) jj_nt = jj_nt.next;
7743 else jj_nt = jj_nt.next = token_source.getNextToken();
7744 if (token.kind == kind) {
7745 jj_gen++;
7746 if (++jj_gc > 100) {
7747 jj_gc = 0;
7748 for (int i = 0; i < jj_2_rtns.length; i++) {
7749 JJCalls c = jj_2_rtns[i];
7750 while (c != null) {
7751 if (c.gen < jj_gen) c.first = null;
7752 c = c.next;
7753 }
7754 }
7755 }
7756 return token;
7757 }
7758 jj_nt = token;
7759 token = oldToken;
7760 jj_kind = kind;
7761 throw generateParseException();
7762 }
7763
7764 final private boolean jj_scan_token(int kind) {
7765 if (jj_scanpos == jj_lastpos) {
7766 jj_la--;
7767 if (jj_scanpos.next == null) {
7768 jj_lastpos = jj_scanpos = jj_scanpos.next = token_source.getNextToken();
7769 } else {
7770 jj_lastpos = jj_scanpos = jj_scanpos.next;
7771 }
7772 } else {
7773 jj_scanpos = jj_scanpos.next;
7774 }
7775 if (jj_rescan) {
7776 int i = 0; Token tok = token;
7777 while (tok != null && tok != jj_scanpos) { i++; tok = tok.next; }
7778 if (tok != null) jj_add_error_token(kind, i);
7779 }
7780 return (jj_scanpos.kind != kind);
7781 }
7782
7783 final public Token getNextToken() {
7784 if ((token = jj_nt).next != null) jj_nt = jj_nt.next;
7785 else jj_nt = jj_nt.next = token_source.getNextToken();
7786 jj_gen++;
7787 return token;
7788 }
7789
7790 final public Token getToken(int index) {
7791 Token t = lookingAhead ? jj_scanpos : token;
7792 for (int i = 0; i < index; i++) {
7793 if (t.next != null) t = t.next;
7794 else t = t.next = token_source.getNextToken();
7795 }
7796 return t;
7797 }
7798
7799 private java.util.Vector jj_expentries = new java.util.Vector();
7800 private int[] jj_expentry;
7801 private int jj_kind = -1;
7802 private int[] jj_lasttokens = new int[100];
7803 private int jj_endpos;
7804
7805 private void jj_add_error_token(int kind, int pos) {
7806 if (pos >= 100) return;
7807 if (pos == jj_endpos + 1) {
7808 jj_lasttokens[jj_endpos++] = kind;
7809 } else if (jj_endpos != 0) {
7810 jj_expentry = new int[jj_endpos];
7811 for (int i = 0; i < jj_endpos; i++) {
7812 jj_expentry[i] = jj_lasttokens[i];
7813 }
7814 boolean exists = false;
7815 for (java.util.Enumeration enum = jj_expentries.elements(); enum.hasMoreElements();) {
7816 int[] oldentry = (int[])(enum.nextElement());
7817 if (oldentry.length == jj_expentry.length) {
7818 exists = true;
7819 for (int i = 0; i < jj_expentry.length; i++) {
7820 if (oldentry[i] != jj_expentry[i]) {
7821 exists = false;
7822 break;
7823 }
7824 }
7825 if (exists) break;
7826 }
7827 }
7828 if (!exists) jj_expentries.addElement(jj_expentry);
7829 if (pos != 0) jj_lasttokens[(jj_endpos = pos) - 1] = kind;
7830 }
7831 }
7832
7833 final public ParseException generateParseException() {
7834 jj_expentries.removeAllElements();
7835 boolean[] la1tokens = new boolean[122];
7836 for (int i = 0; i < 122; i++) {
7837 la1tokens[i] = false;
7838 }
7839 if (jj_kind >= 0) {
7840 la1tokens[jj_kind] = true;
7841 jj_kind = -1;
7842 }
7843 for (int i = 0; i < 129; i++) {
7844 if (jj_la1[i] == jj_gen) {
7845 for (int j = 0; j < 32; j++) {
7846 if ((jj_la1_0[i] & (1<<j)) != 0) {
7847 la1tokens[j] = true;
7848 }
7849 if ((jj_la1_1[i] & (1<<j)) != 0) {
7850 la1tokens[32+j] = true;
7851 }
7852 if ((jj_la1_2[i] & (1<<j)) != 0) {
7853 la1tokens[64+j] = true;
7854 }
7855 if ((jj_la1_3[i] & (1<<j)) != 0) {
7856 la1tokens[96+j] = true;
7857 }
7858 }
7859 }
7860 }
7861 for (int i = 0; i < 122; i++) {
7862 if (la1tokens[i]) {
7863 jj_expentry = new int[1];
7864 jj_expentry[0] = i;
7865 jj_expentries.addElement(jj_expentry);
7866 }
7867 }
7868 jj_endpos = 0;
7869 jj_rescan_token();
7870 jj_add_error_token(0, 0);
7871 int[][] exptokseq = new int[jj_expentries.size()][];
7872 for (int i = 0; i < jj_expentries.size(); i++) {
7873 exptokseq[i] = (int[])jj_expentries.elementAt(i);
7874 }
7875 return new ParseException(token, exptokseq, tokenImage);
7876 }
7877
7878 final public void enable_tracing() {
7879 }
7880
7881 final public void disable_tracing() {
7882 }
7883
7884 final private void jj_rescan_token() {
7885 jj_rescan = true;
7886 for (int i = 0; i < 31; i++) {
7887 JJCalls p = jj_2_rtns[i];
7888 do {
7889 if (p.gen > jj_gen) {
7890 jj_la = p.arg; jj_lastpos = jj_scanpos = p.first;
7891 switch (i) {
7892 case 0: jj_3_1(); break;
7893 case 1: jj_3_2(); break;
7894 case 2: jj_3_3(); break;
7895 case 3: jj_3_4(); break;
7896 case 4: jj_3_5(); break;
7897 case 5: jj_3_6(); break;
7898 case 6: jj_3_7(); break;
7899 case 7: jj_3_8(); break;
7900 case 8: jj_3_9(); break;
7901 case 9: jj_3_10(); break;
7902 case 10: jj_3_11(); break;
7903 case 11: jj_3_12(); break;
7904 case 12: jj_3_13(); break;
7905 case 13: jj_3_14(); break;
7906 case 14: jj_3_15(); break;
7907 case 15: jj_3_16(); break;
7908 case 16: jj_3_17(); break;
7909 case 17: jj_3_18(); break;
7910 case 18: jj_3_19(); break;
7911 case 19: jj_3_20(); break;
7912 case 20: jj_3_21(); break;
7913 case 21: jj_3_22(); break;
7914 case 22: jj_3_23(); break;
7915 case 23: jj_3_24(); break;
7916 case 24: jj_3_25(); break;
7917 case 25: jj_3_26(); break;
7918 case 26: jj_3_27(); break;
7919 case 27: jj_3_28(); break;
7920 case 28: jj_3_29(); break;
7921 case 29: jj_3_30(); break;
7922 case 30: jj_3_31(); break;
7923 }
7924 }
7925 p = p.next;
7926 } while (p != null);
7927 }
7928 jj_rescan = false;
7929 }
7930
7931 final private void jj_save(int index, int xla) {
7932 JJCalls p = jj_2_rtns[index];
7933 while (p.gen > jj_gen) {
7934 if (p.next == null) { p = p.next = new JJCalls(); break; }
7935 p = p.next;
7936 }
7937 p.gen = jj_gen + xla - jj_la; p.first = token; p.arg = xla;
7938 }
7939
7940 static final class JJCalls {
7941 int gen;
7942 Token first;
7943 int arg;
7944 JJCalls next;
7945 }
7946
7947 }