Clover coverage report - PMD - 3.9 Coverage timestamp: Tue Dec 19 2006 09:38:44 EST FRAMES NO FRAMES |
file stats: | LOC: | 9,590 |  | Methods: | 579
| NCLOC: | 8,861 |  | Classes: | 3
Source file | Conditionals | Statements | Methods | TOTAL
JavaParser.java | 45.6% | 57.2% | 85.7% | 55.8% |

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