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