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