Clover coverage report - PMD - 3.7
Coverage timestamp: Wed May 31 2006 09:25:59 EDT

file stats: | LOC: | 9,340 |  | Methods: | 556
| NCLOC: | 8,633 |  | Classes: | 3

Source file | Conditionals | Statements | Methods | TOTAL

JavaParser.java

46.7%

57.5%

87.4%

56.1%

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

9047

223

jj_la1_0 = new int[] {0x0,0x0,0x10081000,0x0,0x0,0x0,0x0,0x10001000,0x10081000,0x10081000,0x10001000,0x10001000,0x10081000,0x0,0x4000000,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,0x510cb000,0x400000,0x10081000,0x4104a000,0x510cb000,};

9048 |  | }
9049 | 223 | private static void jj_la1_1() {

9050

223

jj_la1_1 = new int[] {0x800,0x8,0x51127140,0x0,0x0,0x20000,0x0,0x51127100,0x40,0x51127140,0x0,0x0,0x40,0x0,0x0,0x4,0x0,0x0,0x4,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,0x511371e0,0x0,0x40,0x100a0,0x511371e0,};

9051 |  | }
9052 | 223 | private static void jj_la1_2() {

9053

223

jj_la1_2 = new int[] {0x0,0x0,0x90080,0x0,0x0,0x0,0x40000,0x80000,0x80080,0x90080,0x0,0x0,0x0,0x200000,0x0,0x0,0x20000,0x20000,0x0,0x80,0x20000,0x291080,0x10000,0x400,0x1000,0x20000,0x0,0x0,0x291080,0x200080,0x290080,0x20000,0x100000,0x4000,0xc014e8,0xc014e8,0x20000,0x200000,0x0,0x11000,0x4000,0x20000,0x80080,0x80000,0x80000,0x0,0x200000,0x0,0x0,0x4e8,0x0,0x0,0x80,0x20000,0x0,0x1000080,0x0,0x0,0x80,0x20000,0x100000,0x100000,0x1000000,0x40000000,0x80000000,0x0,0x0,0x0,0x24000000,0x24000000,0x0,0x18200000,0x18200000,0x0,0x0,0x0,0x0,0x0,0x0,0xc004e8,0xc00000,0xc00000,0x4e8,0xc004e8,0x400,0x0,0x0,0x400,0x468,0x80,0x44400,0x68,0x0,0xc004e8,0x20000,0x200000,0x1000,0x4400,0x0,0x4000,0x4000,0x114e8,0x80000,0x80000,0x20000,0x100000,0x0,0x4e8,0x0,0x0,0x0,0x804e8,0xc004e8,0x4e8,0x904e8,0x4e8,0x20000,0x80,0x80,0xc004e8,0x0,0x0,0x2000000,0x80000,0x80,0x20000,0xc814e8,0x20000,0x90080,0x0,0x0,0x80080,0x90080,};

9054 |  | }
9055 | 223 | private static void jj_la1_3() {

9056

223

jj_la1_3 = new int[] {0x0,0x0,0x0,0x4000000,0x8000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x40,0x0,0x0,0x0,0x0,0x0,0x0,0xf,0xf,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x400000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x3ff800,0x3ff800,0x0,0x0,0x0,0x80,0x100,0x40,0x0,0x0,0x0,0x2000000,0x2000000,0x400,0xc,0xc,0x230,0x230,0xc,0xf,0x0,0x0,0x0,0x0,0x0,0x3,0x3,0x0,0x0,0x0,0x0,0x0,0x0,0xf,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x3,0x0,0x0,0x0,0x3ff800,0x3,0x0,0x0,0x0,0x0,0x3,0xf,0x3,0x3,0x3,0x0,0x0,0x0,0xf,0x0,0x0,0x0,0x0,0x0,0x0,0xf,0x0,0x0,0x0,0x0,0x0,0x0,};

9057 |  | }
9058 |  | final private JJCalls[] jj_2_rtns = new JJCalls[50];
9059 |  | private boolean jj_rescan = false;
9060 |  | private int jj_gc = 0;
9061 |  |
9062 | 1211 | public JavaParser(CharStream stream) {
9063 | 1211 | token_source = new JavaParserTokenManager(stream);
9064 | 1211 | token = new Token();
9065 | 1211 | jj_ntk = -1;
9066 | 1211 | jj_gen = 0;
9067 | 161063 | for (int i = 0; i < 133; i++) jj_la1[i] = -1;
9068 | 60550 | for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
9069 |  | }
9070 |  |
9071 | 0 | public void ReInit(CharStream stream) {
9072 | 0 | token_source.ReInit(stream);
9073 | 0 | token = new Token();
9074 | 0 | jj_ntk = -1;
9075 | 0 | jjtree.reset();
9076 | 0 | jj_gen = 0;
9077 | 0 | for (int i = 0; i < 133; i++) jj_la1[i] = -1;
9078 | 0 | for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
9079 |  | }
9080 |  |
9081 | 0 | public JavaParser(JavaParserTokenManager tm) {
9082 | 0 | token_source = tm;
9083 | 0 | token = new Token();
9084 | 0 | jj_ntk = -1;
9085 | 0 | jj_gen = 0;
9086 | 0 | for (int i = 0; i < 133; i++) jj_la1[i] = -1;
9087 | 0 | for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
9088 |  | }
9089 |  |
9090 | 0 | public void ReInit(JavaParserTokenManager tm) {
9091 | 0 | token_source = tm;
9092 | 0 | token = new Token();
9093 | 0 | jj_ntk = -1;
9094 | 0 | jjtree.reset();
9095 | 0 | jj_gen = 0;
9096 | 0 | for (int i = 0; i < 133; i++) jj_la1[i] = -1;
9097 | 0 | for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
9098 |  | }
9099 |  |
9100 | 31432 | final private Token jj_consume_token(int kind) throws ParseException {
9101 | 31432 | Token oldToken;
9102 | ? | if ((oldToken = token).next != null) token = token.next;
9103 | 3681 | else token = token.next = token_source.getNextToken();
9104 | 31432 | jj_ntk = -1;
9105 | 31432 | if (token.kind == kind) {
9106 | 31431 | jj_gen++;
9107 | 31431 | if (++jj_gc > 100) {
9108 | 10 | jj_gc = 0;
9109 | 10 | for (int i = 0; i < jj_2_rtns.length; i++) {
9110 | 500 | JJCalls c = jj_2_rtns[i];
9111 | 500 | while (c != null) {
9112 | 463 | if (c.gen < jj_gen) c.first = null;
9113 | 506 | c = c.next;
9114 |  | }
9115 |  | }
9116 |  | }
9117 | 31431 | return token;
9118 |  | }
9119 | 1 | token = oldToken;
9120 | 1 | jj_kind = kind;
9121 | 1 | throw generateParseException();
9122 |  | }
9123 |  |
9124 |  | static private final class LookaheadSuccess extends java.lang.Error { }
9125 |  | final private LookaheadSuccess jj_ls = new LookaheadSuccess();
9126 | 572972 | final private boolean jj_scan_token(int kind) {
9127 | 572972 | if (jj_scanpos == jj_lastpos) {
9128 | 56639 | jj_la--;
9129 | 56639 | if (jj_scanpos.next == null) {
9130 | 12085 | jj_lastpos = jj_scanpos = jj_scanpos.next = token_source.getNextToken();
9131 |  | } else {
9132 | 44554 | jj_lastpos = jj_scanpos = jj_scanpos.next;
9133 |  | }
9134 |  | } else {
9135 | 516333 | jj_scanpos = jj_scanpos.next;
9136 |  | }
9137 | 572972 | if (jj_rescan) {
9138 | 159 | int i = 0; Token tok = token;
9139 | 218 | while (tok != null && tok != jj_scanpos) { i++; tok = tok.next; }
9140 | 58 | if (tok != null) jj_add_error_token(kind, i);
9141 |  | }
9142 | 546826 | if (jj_scanpos.kind != kind) return true;
9143 | 4755 | if (jj_la == 0 && jj_scanpos == jj_lastpos) throw jj_ls;
9144 | 21391 | return false;
9145 |  | }
9146 |  |
9147 | 0 | final public Token getNextToken() {
9148 | 0 | if (token.next != null) token = token.next;
9149 | 0 | else token = token.next = token_source.getNextToken();
9150 | 0 | jj_ntk = -1;
9151 | 0 | jj_gen++;
9152 | 0 | return token;
9153 |  | }
9154 |  |
9155 | 15322 | final public Token getToken(int index) {
9156 | 15322 | Token t = lookingAhead ? jj_scanpos : token;
9157 | 15322 | for (int i = 0; i < index; i++) {
9158 | 12000 | if (t.next != null) t = t.next;
9159 | 3330 | else t = t.next = token_source.getNextToken();
9160 |  | }
9161 | 15322 | return t;
9162 |  | }
9163 |  |
9164 | 22869 | final private int jj_ntk() {
9165 | ? | if ((jj_nt=token.next) == null)
9166 | 12343 | return (jj_ntk = (token.next=token_source.getNextToken()).kind);
9167 |  | else
9168 | 10526 | return (jj_ntk = jj_nt.kind);
9169 |  | }
9170 |  |
9171 |  | private java.util.Vector jj_expentries = new java.util.Vector();
9172 |  | private int[] jj_expentry;
9173 |  | private int jj_kind = -1;
9174 |  | private int[] jj_lasttokens = new int[100];
9175 |  | private int jj_endpos;
9176 |  |
9177 | 59 | private void jj_add_error_token(int kind, int pos) {
9178 | 0 | if (pos >= 100) return;
9179 | 59 | if (pos == jj_endpos + 1) {
9180 | 1 | jj_lasttokens[jj_endpos++] = kind;
9181 | 58 | } else if (jj_endpos != 0) {
9182 | 58 | jj_expentry = new int[jj_endpos];
9183 | 58 | for (int i = 0; i < jj_endpos; i++) {
9184 | 58 | jj_expentry[i] = jj_lasttokens[i];
9185 |  | }
9186 | 58 | boolean exists = false;
9187 | 58 | for (java.util.Enumeration e = jj_expentries.elements(); e.hasMoreElements();) {
9188 | 904 | int[] oldentry = (int[])(e.nextElement());
9189 | 904 | if (oldentry.length == jj_expentry.length) {
9190 | 904 | exists = true;
9191 | 904 | for (int i = 0; i < jj_expentry.length; i++) {
9192 | 904 | if (oldentry[i] != jj_expentry[i]) {
9193 | 851 | exists = false;
9194 | 851 | break;
9195 |  | }
9196 |  | }
9197 | 53 | if (exists) break;
9198 |  | }
9199 |  | }
9200 | 5 | if (!exists) jj_expentries.addElement(jj_expentry);
9201 | 15 | if (pos != 0) jj_lasttokens[(jj_endpos = pos) - 1] = kind;
9202 |  | }
9203 |  | }
9204 |  |
9205 | 1 | public ParseException generateParseException() {
9206 | 1 | jj_expentries.removeAllElements();
9207 | 1 | boolean[] la1tokens = new boolean[124];
9208 | 1 | for (int i = 0; i < 124; i++) {
9209 | 124 | la1tokens[i] = false;
9210 |  | }
9211 | 1 | if (jj_kind >= 0) {
9212 | 1 | la1tokens[jj_kind] = true;
9213 | 1 | jj_kind = -1;
9214 |  | }
9215 | 1 | for (int i = 0; i < 133; i++) {
9216 | 133 | if (jj_la1[i] == jj_gen) {
9217 | 1 | for (int j = 0; j < 32; j++) {
9218 | 32 | if ((jj_la1_0[i] & (1<<j)) != 0) {
9219 | 0 | la1tokens[j] = true;
9220 |  | }
9221 | 32 | if ((jj_la1_1[i] & (1<<j)) != 0) {
9222 | 0 | la1tokens[32+j] = true;
9223 |  | }
9224 | 32 | if ((jj_la1_2[i] & (1<<j)) != 0) {
9225 | 1 | la1tokens[64+j] = true;
9226 |  | }
9227 | 32 | if ((jj_la1_3[i] & (1<<j)) != 0) {
9228 | 11 | la1tokens[96+j] = true;
9229 |  | }
9230 |  | }
9231 |  | }
9232 |  | }
9233 | 1 | for (int i = 0; i < 124; i++) {
9234 | 124 | if (la1tokens[i]) {
9235 | 13 | jj_expentry = new int[1];
9236 | 13 | jj_expentry[0] = i;
9237 | 13 | jj_expentries.addElement(jj_expentry);
9238 |  | }
9239 |  | }
9240 | 1 | jj_endpos = 0;
9241 | 1 | jj_rescan_token();
9242 | 1 | jj_add_error_token(0, 0);
9243 | 1 | int[][] exptokseq = new int[jj_expentries.size()][];
9244 | 1 | for (int i = 0; i < jj_expentries.size(); i++) {
9245 | 18 | exptokseq[i] = (int[])jj_expentries.elementAt(i);
9246 |  | }
9247 | 1 | return new ParseException(token, exptokseq, tokenImage);
9248 |  | }
9249 |  |
9250 | 0 | final public void enable_tracing() {
9251 |  | }
9252 |  |
9253 | 0 | final public void disable_tracing() {
9254 |  | }
9255 |  |
9256 | 1 | final private void jj_rescan_token() {
9257 | 1 | jj_rescan = true;
9258 | 1 | for (int i = 0; i < 50; i++) {
9259 | 50 | try {
9260 | 50 | JJCalls p = jj_2_rtns[i];
9261 | 50 | do {
9262 | 50 | if (p.gen > jj_gen) {
9263 | 2 | jj_la = p.arg; jj_lastpos = jj_scanpos = p.first;
9264 | 2 | switch (i) {
9265 | 0 | case 0: jj_3_1(); break;
9266 | 0 | case 1: jj_3_2(); break;
9267 | 0 | case 2: jj_3_3(); break;
9268 | 0 | case 3: jj_3_4(); break;
9269 | 0 | case 4: jj_3_5(); break;
9270 | 0 | case 5: jj_3_6(); break;
9271 | 0 | case 6: jj_3_7(); break;
9272 | 0 | case 7: jj_3_8(); break;
9273 | 0 | case 8: jj_3_9(); break;
9274 | 0 | case 9: jj_3_10(); break;
9275 | 0 | case 10: jj_3_11(); break;
9276 | 0 | case 11: jj_3_12(); break;
9277 | 0 | case 12: jj_3_13(); break;
9278 | 0 | case 13: jj_3_14(); break;
9279 | 0 | case 14: jj_3_15(); break;
9280 | 0 | case 15: jj_3_16(); break;
9281 | 0 | case 16: jj_3_17(); break;
9282 | 0 | case 17: jj_3_18(); break;
9283 | 0 | case 18: jj_3_19(); break;
9284 | 0 | case 19: jj_3_20(); break;
9285 | 0 | case 20: jj_3_21(); break;
9286 | 0 | case 21: jj_3_22(); break;
9287 | 0 | case 22: jj_3_23(); break;
9288 | 0 | case 23: jj_3_24(); break;
9289 | 0 | case 24: jj_3_25(); break;
9290 | 0 | case 25: jj_3_26(); break;
9291 | 1 | case 26: jj_3_27(); break;
9292 | 0 | case 27: jj_3_28(); break;
9293 | 0 | case 28: jj_3_29(); break;
9294 | 0 | case 29: jj_3_30(); break;
9295 | 0 | case 30: jj_3_31(); break;
9296 | 0 | case 31: jj_3_32(); break;
9297 | 0 | case 32: jj_3_33(); break;
9298 | 0 | case 33: jj_3_34(); break;
9299 | 0 | case 34: jj_3_35(); break;
9300 | 0 | case 35: jj_3_36(); break;
9301 | 0 | case 36: jj_3_37(); break;
9302 | 0 | case 37: jj_3_38(); break;
9303 | 0 | case 38: jj_3_39(); break;
9304 | 0 | case 39: jj_3_40(); break;
9305 | 0 | case 40: jj_3_41(); break;
9306 | 1 | case 41: jj_3_42(); break;
9307 | 0 | case 42: jj_3_43(); break;
9308 | 0 | case 43: jj_3_44(); break;
9309 | 0 | case 44: jj_3_45(); break;
9310 | 0 | case 45: jj_3_46(); break;
9311 | 0 | case 46: jj_3_47(); break;
9312 | 0 | case 47: jj_3_48(); break;
9313 | 0 | case 48: jj_3_49(); break;
9314 | 0 | case 49: jj_3_50(); break;
9315 |  | }
9316 |  | }
9317 | 50 | p = p.next;
9318 | 50 | } while (p != null);
9319 |  | } catch(LookaheadSuccess ls) { }
9320 |  | }
9321 | 1 | jj_rescan = false;
9322 |  | }
9323 |  |
9324 | 41710 | final private void jj_save(int index, int xla) {
9325 | 41710 | JJCalls p = jj_2_rtns[index];
9326 | 41710 | while (p.gen > jj_gen) {
9327 | 47 | if (p.next == null) { p = p.next = new JJCalls(); break; }
9328 | 15 | p = p.next;
9329 |  | }
9330 | 41710 | p.gen = jj_gen + xla - jj_la; p.first = token; p.arg = xla;
9331 |  | }
9332 |  |
9333 |  | static final class JJCalls {
9334 |  | int gen;
9335 |  | Token first;
9336 |  | int arg;
9337 |  | JJCalls next;
9338 |  | }
9339 |  |
9340 |  | }