1 | package com.hammurapi.grammar.java; |
2 | // $ANTLR 2.7.5 (20050128): "java15.g" -> "JavaRecognizer.java"$ |
3 | |
4 | import antlr.TokenBuffer; |
5 | import antlr.TokenStreamException; |
6 | import antlr.TokenStreamIOException; |
7 | import antlr.ANTLRException; |
8 | import antlr.LLkParser; |
9 | import antlr.Token; |
10 | import antlr.TokenStream; |
11 | import antlr.RecognitionException; |
12 | import antlr.NoViableAltException; |
13 | import antlr.MismatchedTokenException; |
14 | import antlr.SemanticException; |
15 | import antlr.ParserSharedInputState; |
16 | import antlr.collections.impl.BitSet; |
17 | import antlr.collections.AST; |
18 | import java.util.Hashtable; |
19 | import antlr.ASTFactory; |
20 | import antlr.ASTPair; |
21 | import antlr.collections.impl.ASTArray; |
22 | |
23 | /** Java 1.5 Recognizer |
24 | /** Java 1.5 Recognizer |
25 | * |
26 | * Run 'java Main [-showtree] directory-full-of-java-files' |
27 | * |
28 | * [The -showtree option pops up a Swing frame that shows |
29 | * the AST constructed from the parser.] |
30 | * |
31 | * Run 'java Main <directory full of java files>' |
32 | * |
33 | * Contributing authors: |
34 | * John Mitchell johnm@non.net |
35 | * Terence Parr parrt@magelang.com |
36 | * John Lilley jlilley@empathy.com |
37 | * Scott Stanchfield thetick@magelang.com |
38 | * Markus Mohnen mohnen@informatik.rwth-aachen.de |
39 | * Peter Williams pete.williams@sun.com |
40 | * Allan Jacobs Allan.Jacobs@eng.sun.com |
41 | * Steve Messick messick@redhills.com |
42 | * John Pybus john@pybus.org |
43 | * |
44 | * Version 1.00 December 9, 1997 -- initial release |
45 | * Version 1.01 December 10, 1997 |
46 | * fixed bug in octal def (0..7 not 0..8) |
47 | * Version 1.10 August 1998 (parrt) |
48 | * added tree construction |
49 | * fixed definition of WS,comments for mac,pc,unix newlines |
50 | * added unary plus |
51 | * Version 1.11 (Nov 20, 1998) |
52 | * Added "shutup" option to turn off last ambig warning. |
53 | * Fixed inner class def to allow named class defs as statements |
54 | * synchronized requires compound not simple statement |
55 | * add [] after builtInType DOT class in primaryExpression |
56 | * "const" is reserved but not valid..removed from modifiers |
57 | * Version 1.12 (Feb 2, 1999) |
58 | * Changed LITERAL_xxx to xxx in tree grammar. |
59 | * Updated java.g to use tokens {...} now for 2.6.0 (new feature). |
60 | * |
61 | * Version 1.13 (Apr 23, 1999) |
62 | * Didn't have (stat)? for else clause in tree parser. |
63 | * Didn't gen ASTs for interface extends. Updated tree parser too. |
64 | * Updated to 2.6.0. |
65 | * Version 1.14 (Jun 20, 1999) |
66 | * Allowed final/abstract on local classes. |
67 | * Removed local interfaces from methods |
68 | * Put instanceof precedence where it belongs...in relationalExpr |
69 | * It also had expr not type as arg; fixed it. |
70 | * Missing ! on SEMI in classBlock |
71 | * fixed: (expr) + "string" was parsed incorrectly (+ as unary plus). |
72 | * fixed: didn't like Object[].class in parser or tree parser |
73 | * Version 1.15 (Jun 26, 1999) |
74 | * Screwed up rule with instanceof in it. :( Fixed. |
75 | * Tree parser didn't like (expr).something; fixed. |
76 | * Allowed multiple inheritance in tree grammar. oops. |
77 | * Version 1.16 (August 22, 1999) |
78 | * Extending an interface built a wacky tree: had extra EXTENDS. |
79 | * Tree grammar didn't allow multiple superinterfaces. |
80 | * Tree grammar didn't allow empty var initializer: {} |
81 | * Version 1.17 (October 12, 1999) |
82 | * ESC lexer rule allowed 399 max not 377 max. |
83 | * java.tree.g didn't handle the expression of synchronized |
84 | * statements. |
85 | * Version 1.18 (August 12, 2001) |
86 | * Terence updated to Java 2 Version 1.3 by |
87 | * observing/combining work of Allan Jacobs and Steve |
88 | * Messick. Handles 1.3 src. Summary: |
89 | * o primary didn't include boolean.class kind of thing |
90 | * o constructor calls parsed explicitly now: |
91 | * see explicitConstructorInvocation |
92 | * o add strictfp modifier |
93 | * o missing objBlock after new expression in tree grammar |
94 | * o merged local class definition alternatives, moved after declaration |
95 | * o fixed problem with ClassName.super.field |
96 | * o reordered some alternatives to make things more efficient |
97 | * o long and double constants were not differentiated from int/float |
98 | * o whitespace rule was inefficient: matched only one char |
99 | * o add an examples directory with some nasty 1.3 cases |
100 | * o made Main.java use buffered IO and a Reader for Unicode support |
101 | * o supports UNICODE? |
102 | * Using Unicode charVocabulay makes code file big, but only |
103 | * in the bitsets at the end. I need to make ANTLR generate |
104 | * unicode bitsets more efficiently. |
105 | * Version 1.19 (April 25, 2002) |
106 | * Terence added in nice fixes by John Pybus concerning floating |
107 | * constants and problems with super() calls. John did a nice |
108 | * reorg of the primary/postfix expression stuff to read better |
109 | * and makes f.g.super() parse properly (it was METHOD_CALL not |
110 | * a SUPER_CTOR_CALL). Also: |
111 | * |
112 | * o "finally" clause was a root...made it a child of "try" |
113 | * o Added stuff for asserts too for Java 1.4, but *commented out* |
114 | * as it is not backward compatible. |
115 | * |
116 | * Version 1.20 (October 27, 2002) |
117 | * |
118 | * Terence ended up reorging John Pybus' stuff to |
119 | * remove some nondeterminisms and some syntactic predicates. |
120 | * Note that the grammar is stricter now; e.g., this(...) must |
121 | * be the first statement. |
122 | * |
123 | * Trinary ?: operator wasn't working as array name: |
124 | * (isBig ? bigDigits : digits)[i]; |
125 | * |
126 | * Checked parser/tree parser on source for |
127 | * Resin-2.0.5, jive-2.1.1, jdk 1.3.1, Lucene, antlr 2.7.2a4, |
128 | * and the 110k-line jGuru server source. |
129 | * |
130 | * Version 1.21 (October 17, 2003) |
131 | * Fixed lots of problems including: |
132 | * Ray Waldin: add typeDefinition to interfaceBlock in java.tree.g |
133 | * He found a problem/fix with floating point that start with 0 |
134 | * Ray also fixed problem that (int.class) was not recognized. |
135 | * Thorsten van Ellen noticed that \n are allowed incorrectly in strings. |
136 | * TJP fixed CHAR_LITERAL analogously. |
137 | * |
138 | * Version 1.21.2 (March, 2003) |
139 | * Changes by Matt Quail to support generics (as per JDK1.5/JSR14) |
140 | * Notes: |
141 | * o We only allow the "extends" keyword and not the "implements" |
142 | * keyword, since thats what JSR14 seems to imply. |
143 | * o Thanks to Monty Zukowski for his help on the antlr-interest |
144 | * mail list. |
145 | * o Thanks to Alan Eliasen for testing the grammar over his |
146 | * Fink source base |
147 | * |
148 | * Version 1.22 (July, 2004) |
149 | * Changes by Michael Studman to support Java 1.5 language extensions |
150 | * Notes: |
151 | * o Added support for annotations types |
152 | * o Finished off Matt Quail's generics enhancements to support bound type arguments |
153 | * o Added support for new for statement syntax |
154 | * o Added support for static import syntax |
155 | * o Added support for enum types |
156 | * o Tested against JDK 1.5 source base and source base of jdigraph project |
157 | * o Thanks to Matt Quail for doing the hard part by doing most of the generics work |
158 | * |
159 | * Version 1.22.1 (July 28, 2004) |
160 | * Bug/omission fixes for Java 1.5 language support |
161 | * o Fixed tree structure bug with classOrInterface - thanks to Pieter Vangorpto for |
162 | * spotting this |
163 | * o Fixed bug where incorrect handling of SR and BSR tokens would cause type |
164 | * parameters to be recognised as type arguments. |
165 | * o Enabled type parameters on constructors, annotations on enum constants |
166 | * and package definitions |
167 | * o Fixed problems when parsing if ((char.class.equals(c))) {} - solution by Matt Quail at Cenqua |
168 | * |
169 | * Version 1.22.2 (July 28, 2004) |
170 | * Slight refactoring of Java 1.5 language support |
171 | * o Refactored for/"foreach" productions so that original literal "for" literal |
172 | * is still used but the for sub-clauses vary by token type |
173 | * o Fixed bug where type parameter was not included in generic constructor's branch of AST |
174 | * |
175 | * Version 1.22.3 (August 26, 2004) |
176 | * Bug fixes as identified by Michael Stahl; clean up of tabs/spaces |
177 | * and other refactorings |
178 | * o Fixed typeParameters omission in identPrimary and newStatement |
179 | * o Replaced GT reconcilliation code with simple semantic predicate |
180 | * o Adapted enum/assert keyword checking support from Michael Stahl's java15 grammar |
181 | * o Refactored typeDefinition production and field productions to reduce duplication |
182 | * |
183 | * Version 1.22.4 (October 21, 2004) |
184 | * Small bux fixes |
185 | * o Added typeArguments to explicitConstructorInvocation, e.g. new <String>MyParameterised() |
186 | * o Added typeArguments to postfixExpression productions for anonymous inner class super |
187 | * constructor invocation, e.g. new Outer().<String>super() |
188 | * o Fixed bug in array declarations identified by Geoff Roy |
189 | * |
190 | * Version 1.22.5 (January 03, 2005) |
191 | * Small change to tree structure |
192 | * o Flattened classOrInterfaceType tree so IDENT no longer has children. TYPE_ARGUMENTS are now |
193 | * always siblings of IDENT rather than children. Fully.qualified.names trees now |
194 | * look a little less clean when TYPE_ARGUMENTS are present though. |
195 | * |
196 | * This grammar is in the PUBLIC DOMAIN |
197 | */ |
198 | public class JavaRecognizer extends antlr.LLkParser implements JavaTokenTypes |
199 | { |
200 | |
201 | /** |
202 | * Counts the number of LT seen in the typeArguments production. |
203 | * It is used in semantic predicates to ensure we have seen |
204 | * enough closing '>' characters; which actually may have been |
205 | * either GT, SR or BSR tokens. |
206 | */ |
207 | private int ltCounter = 0; |
208 | |
209 | protected JavaRecognizer(TokenBuffer tokenBuf, int k) { |
210 | super(tokenBuf,k); |
211 | tokenNames = _tokenNames; |
212 | buildTokenTypeASTClassMap(); |
213 | astFactory = new ASTFactory(getTokenTypeToASTClassMap()); |
214 | } |
215 | |
216 | public JavaRecognizer(TokenBuffer tokenBuf) { |
217 | this(tokenBuf,2); |
218 | } |
219 | |
220 | protected JavaRecognizer(TokenStream lexer, int k) { |
221 | super(lexer,k); |
222 | tokenNames = _tokenNames; |
223 | buildTokenTypeASTClassMap(); |
224 | astFactory = new ASTFactory(getTokenTypeToASTClassMap()); |
225 | } |
226 | |
227 | public JavaRecognizer(TokenStream lexer) { |
228 | this(lexer,2); |
229 | } |
230 | |
231 | public JavaRecognizer(ParserSharedInputState state) { |
232 | super(state,2); |
233 | tokenNames = _tokenNames; |
234 | buildTokenTypeASTClassMap(); |
235 | astFactory = new ASTFactory(getTokenTypeToASTClassMap()); |
236 | } |
237 | |
238 | public final void compilationUnit() throws RecognitionException, TokenStreamException { |
239 | |
240 | returnAST = null; |
241 | ASTPair currentAST = new ASTPair(); |
242 | AST compilationUnit_AST = null; |
243 | |
244 | { |
245 | boolean synPredMatched4 = false; |
246 | if (((LA(1)==LITERAL_package||LA(1)==AT) && (LA(2)==IDENT))) { |
247 | int _m4 = mark(); |
248 | synPredMatched4 = true; |
249 | inputState.guessing++; |
250 | try { |
251 | { |
252 | annotations(); |
253 | match(LITERAL_package); |
254 | } |
255 | } |
256 | catch (RecognitionException pe) { |
257 | synPredMatched4 = false; |
258 | } |
259 | rewind(_m4); |
260 | inputState.guessing--; |
261 | } |
262 | if ( synPredMatched4 ) { |
263 | packageDefinition(); |
264 | astFactory.addASTChild(currentAST, returnAST); |
265 | } |
266 | else if ((_tokenSet_0.member(LA(1))) && (_tokenSet_1.member(LA(2)))) { |
267 | } |
268 | else { |
269 | throw new NoViableAltException(LT(1), getFilename()); |
270 | } |
271 | |
272 | } |
273 | { |
274 | _loop6: |
275 | do { |
276 | if ((LA(1)==LITERAL_import)) { |
277 | importDefinition(); |
278 | astFactory.addASTChild(currentAST, returnAST); |
279 | } |
280 | else { |
281 | break _loop6; |
282 | } |
283 | |
284 | } while (true); |
285 | } |
286 | { |
287 | _loop8: |
288 | do { |
289 | if ((_tokenSet_2.member(LA(1)))) { |
290 | typeDefinition(); |
291 | astFactory.addASTChild(currentAST, returnAST); |
292 | } |
293 | else { |
294 | break _loop8; |
295 | } |
296 | |
297 | } while (true); |
298 | } |
299 | match(Token.EOF_TYPE); |
300 | compilationUnit_AST = (AST)currentAST.root; |
301 | returnAST = compilationUnit_AST; |
302 | } |
303 | |
304 | public final void annotations() throws RecognitionException, TokenStreamException { |
305 | |
306 | returnAST = null; |
307 | ASTPair currentAST = new ASTPair(); |
308 | AST annotations_AST = null; |
309 | |
310 | { |
311 | _loop62: |
312 | do { |
313 | if ((LA(1)==AT)) { |
314 | annotation(); |
315 | astFactory.addASTChild(currentAST, returnAST); |
316 | } |
317 | else { |
318 | break _loop62; |
319 | } |
320 | |
321 | } while (true); |
322 | } |
323 | if ( inputState.guessing==0 ) { |
324 | annotations_AST = (AST)currentAST.root; |
325 | annotations_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(ANNOTATIONS,"ANNOTATIONS")).add(annotations_AST)); |
326 | currentAST.root = annotations_AST; |
327 | currentAST.child = annotations_AST!=null &&annotations_AST.getFirstChild()!=null ? |
328 | annotations_AST.getFirstChild() : annotations_AST; |
329 | currentAST.advanceChildToEnd(); |
330 | } |
331 | annotations_AST = (AST)currentAST.root; |
332 | returnAST = annotations_AST; |
333 | } |
334 | |
335 | public final void packageDefinition() throws RecognitionException, TokenStreamException { |
336 | |
337 | returnAST = null; |
338 | ASTPair currentAST = new ASTPair(); |
339 | AST packageDefinition_AST = null; |
340 | Token p = null; |
341 | AST p_AST = null; |
342 | |
343 | try { // for error handling |
344 | annotations(); |
345 | astFactory.addASTChild(currentAST, returnAST); |
346 | p = LT(1); |
347 | p_AST = astFactory.create(p); |
348 | astFactory.makeASTRoot(currentAST, p_AST); |
349 | match(LITERAL_package); |
350 | if ( inputState.guessing==0 ) { |
351 | p_AST.setType(PACKAGE_DEF); |
352 | } |
353 | identifier(); |
354 | astFactory.addASTChild(currentAST, returnAST); |
355 | match(SEMI); |
356 | packageDefinition_AST = (AST)currentAST.root; |
357 | } |
358 | catch (RecognitionException ex) { |
359 | if (inputState.guessing==0) { |
360 | reportError(ex); |
361 | recover(ex,_tokenSet_0); |
362 | } else { |
363 | throw ex; |
364 | } |
365 | } |
366 | returnAST = packageDefinition_AST; |
367 | } |
368 | |
369 | public final void importDefinition() throws RecognitionException, TokenStreamException { |
370 | |
371 | returnAST = null; |
372 | ASTPair currentAST = new ASTPair(); |
373 | AST importDefinition_AST = null; |
374 | Token i = null; |
375 | AST i_AST = null; |
376 | boolean isStatic = false; |
377 | |
378 | try { // for error handling |
379 | i = LT(1); |
380 | i_AST = astFactory.create(i); |
381 | astFactory.makeASTRoot(currentAST, i_AST); |
382 | match(LITERAL_import); |
383 | if ( inputState.guessing==0 ) { |
384 | i_AST.setType(IMPORT); |
385 | } |
386 | { |
387 | switch ( LA(1)) { |
388 | case LITERAL_static: |
389 | { |
390 | match(LITERAL_static); |
391 | if ( inputState.guessing==0 ) { |
392 | i_AST.setType(STATIC_IMPORT); |
393 | } |
394 | break; |
395 | } |
396 | case IDENT: |
397 | { |
398 | break; |
399 | } |
400 | default: |
401 | { |
402 | throw new NoViableAltException(LT(1), getFilename()); |
403 | } |
404 | } |
405 | } |
406 | identifierStar(); |
407 | astFactory.addASTChild(currentAST, returnAST); |
408 | match(SEMI); |
409 | importDefinition_AST = (AST)currentAST.root; |
410 | } |
411 | catch (RecognitionException ex) { |
412 | if (inputState.guessing==0) { |
413 | reportError(ex); |
414 | recover(ex,_tokenSet_0); |
415 | } else { |
416 | throw ex; |
417 | } |
418 | } |
419 | returnAST = importDefinition_AST; |
420 | } |
421 | |
422 | public final void typeDefinition() throws RecognitionException, TokenStreamException { |
423 | |
424 | returnAST = null; |
425 | ASTPair currentAST = new ASTPair(); |
426 | AST typeDefinition_AST = null; |
427 | AST m_AST = null; |
428 | |
429 | try { // for error handling |
430 | switch ( LA(1)) { |
431 | case FINAL: |
432 | case ABSTRACT: |
433 | case STRICTFP: |
434 | case LITERAL_static: |
435 | case LITERAL_private: |
436 | case LITERAL_public: |
437 | case LITERAL_protected: |
438 | case LITERAL_transient: |
439 | case LITERAL_native: |
440 | case LITERAL_threadsafe: |
441 | case LITERAL_synchronized: |
442 | case LITERAL_volatile: |
443 | case AT: |
444 | case LITERAL_class: |
445 | case LITERAL_interface: |
446 | case LITERAL_enum: |
447 | { |
448 | modifiers(); |
449 | m_AST = (AST)returnAST; |
450 | typeDefinitionInternal(m_AST); |
451 | astFactory.addASTChild(currentAST, returnAST); |
452 | typeDefinition_AST = (AST)currentAST.root; |
453 | break; |
454 | } |
455 | case SEMI: |
456 | { |
457 | match(SEMI); |
458 | typeDefinition_AST = (AST)currentAST.root; |
459 | break; |
460 | } |
461 | default: |
462 | { |
463 | throw new NoViableAltException(LT(1), getFilename()); |
464 | } |
465 | } |
466 | } |
467 | catch (RecognitionException ex) { |
468 | if (inputState.guessing==0) { |
469 | reportError(ex); |
470 | recover(ex,_tokenSet_3); |
471 | } else { |
472 | throw ex; |
473 | } |
474 | } |
475 | returnAST = typeDefinition_AST; |
476 | } |
477 | |
478 | public final void identifier() throws RecognitionException, TokenStreamException { |
479 | |
480 | returnAST = null; |
481 | ASTPair currentAST = new ASTPair(); |
482 | AST identifier_AST = null; |
483 | |
484 | AST tmp6_AST = null; |
485 | tmp6_AST = astFactory.create(LT(1)); |
486 | astFactory.addASTChild(currentAST, tmp6_AST); |
487 | match(IDENT); |
488 | { |
489 | _loop48: |
490 | do { |
491 | if ((LA(1)==DOT)) { |
492 | AST tmp7_AST = null; |
493 | tmp7_AST = astFactory.create(LT(1)); |
494 | astFactory.makeASTRoot(currentAST, tmp7_AST); |
495 | match(DOT); |
496 | AST tmp8_AST = null; |
497 | tmp8_AST = astFactory.create(LT(1)); |
498 | astFactory.addASTChild(currentAST, tmp8_AST); |
499 | match(IDENT); |
500 | } |
501 | else { |
502 | break _loop48; |
503 | } |
504 | |
505 | } while (true); |
506 | } |
507 | identifier_AST = (AST)currentAST.root; |
508 | returnAST = identifier_AST; |
509 | } |
510 | |
511 | public final void identifierStar() throws RecognitionException, TokenStreamException { |
512 | |
513 | returnAST = null; |
514 | ASTPair currentAST = new ASTPair(); |
515 | AST identifierStar_AST = null; |
516 | |
517 | AST tmp9_AST = null; |
518 | tmp9_AST = astFactory.create(LT(1)); |
519 | astFactory.addASTChild(currentAST, tmp9_AST); |
520 | match(IDENT); |
521 | { |
522 | _loop51: |
523 | do { |
524 | if ((LA(1)==DOT) && (LA(2)==IDENT)) { |
525 | AST tmp10_AST = null; |
526 | tmp10_AST = astFactory.create(LT(1)); |
527 | astFactory.makeASTRoot(currentAST, tmp10_AST); |
528 | match(DOT); |
529 | AST tmp11_AST = null; |
530 | tmp11_AST = astFactory.create(LT(1)); |
531 | astFactory.addASTChild(currentAST, tmp11_AST); |
532 | match(IDENT); |
533 | } |
534 | else { |
535 | break _loop51; |
536 | } |
537 | |
538 | } while (true); |
539 | } |
540 | { |
541 | switch ( LA(1)) { |
542 | case DOT: |
543 | { |
544 | AST tmp12_AST = null; |
545 | tmp12_AST = astFactory.create(LT(1)); |
546 | astFactory.makeASTRoot(currentAST, tmp12_AST); |
547 | match(DOT); |
548 | AST tmp13_AST = null; |
549 | tmp13_AST = astFactory.create(LT(1)); |
550 | astFactory.addASTChild(currentAST, tmp13_AST); |
551 | match(STAR); |
552 | break; |
553 | } |
554 | case SEMI: |
555 | { |
556 | break; |
557 | } |
558 | default: |
559 | { |
560 | throw new NoViableAltException(LT(1), getFilename()); |
561 | } |
562 | } |
563 | } |
564 | identifierStar_AST = (AST)currentAST.root; |
565 | returnAST = identifierStar_AST; |
566 | } |
567 | |
568 | public final void modifiers() throws RecognitionException, TokenStreamException { |
569 | |
570 | returnAST = null; |
571 | ASTPair currentAST = new ASTPair(); |
572 | AST modifiers_AST = null; |
573 | |
574 | { |
575 | _loop55: |
576 | do { |
577 | if ((_tokenSet_4.member(LA(1)))) { |
578 | modifier(); |
579 | astFactory.addASTChild(currentAST, returnAST); |
580 | } |
581 | else if (((LA(1)==AT) && (LA(2)==IDENT))&&(LA(1)==AT && !LT(2).getText().equals("interface"))) { |
582 | annotation(); |
583 | astFactory.addASTChild(currentAST, returnAST); |
584 | } |
585 | else { |
586 | break _loop55; |
587 | } |
588 | |
589 | } while (true); |
590 | } |
591 | if ( inputState.guessing==0 ) { |
592 | modifiers_AST = (AST)currentAST.root; |
593 | modifiers_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(MODIFIERS,"MODIFIERS")).add(modifiers_AST)); |
594 | currentAST.root = modifiers_AST; |
595 | currentAST.child = modifiers_AST!=null &&modifiers_AST.getFirstChild()!=null ? |
596 | modifiers_AST.getFirstChild() : modifiers_AST; |
597 | currentAST.advanceChildToEnd(); |
598 | } |
599 | modifiers_AST = (AST)currentAST.root; |
600 | returnAST = modifiers_AST; |
601 | } |
602 | |
603 | protected final void typeDefinitionInternal( |
604 | AST mods |
605 | ) throws RecognitionException, TokenStreamException { |
606 | |
607 | returnAST = null; |
608 | ASTPair currentAST = new ASTPair(); |
609 | AST typeDefinitionInternal_AST = null; |
610 | |
611 | switch ( LA(1)) { |
612 | case LITERAL_class: |
613 | { |
614 | classDefinition(mods); |
615 | astFactory.addASTChild(currentAST, returnAST); |
616 | typeDefinitionInternal_AST = (AST)currentAST.root; |
617 | break; |
618 | } |
619 | case LITERAL_interface: |
620 | { |
621 | interfaceDefinition(mods); |
622 | astFactory.addASTChild(currentAST, returnAST); |
623 | typeDefinitionInternal_AST = (AST)currentAST.root; |
624 | break; |
625 | } |
626 | case LITERAL_enum: |
627 | { |
628 | enumDefinition(mods); |
629 | astFactory.addASTChild(currentAST, returnAST); |
630 | typeDefinitionInternal_AST = (AST)currentAST.root; |
631 | break; |
632 | } |
633 | case AT: |
634 | { |
635 | annotationDefinition(mods); |
636 | astFactory.addASTChild(currentAST, returnAST); |
637 | typeDefinitionInternal_AST = (AST)currentAST.root; |
638 | break; |
639 | } |
640 | default: |
641 | { |
642 | throw new NoViableAltException(LT(1), getFilename()); |
643 | } |
644 | } |
645 | returnAST = typeDefinitionInternal_AST; |
646 | } |
647 | |
648 | public final void classDefinition( |
649 | AST modifiers |
650 | ) throws RecognitionException, TokenStreamException { |
651 | |
652 | returnAST = null; |
653 | ASTPair currentAST = new ASTPair(); |
654 | AST classDefinition_AST = null; |
655 | AST tp_AST = null; |
656 | AST sc_AST = null; |
657 | AST ic_AST = null; |
658 | AST cb_AST = null; |
659 | |
660 | match(LITERAL_class); |
661 | AST tmp15_AST = null; |
662 | tmp15_AST = astFactory.create(LT(1)); |
663 | match(IDENT); |
664 | { |
665 | switch ( LA(1)) { |
666 | case LT: |
667 | { |
668 | typeParameters(); |
669 | tp_AST = (AST)returnAST; |
670 | break; |
671 | } |
672 | case LITERAL_extends: |
673 | case LCURLY: |
674 | case LITERAL_implements: |
675 | { |
676 | break; |
677 | } |
678 | default: |
679 | { |
680 | throw new NoViableAltException(LT(1), getFilename()); |
681 | } |
682 | } |
683 | } |
684 | superClassClause(); |
685 | sc_AST = (AST)returnAST; |
686 | implementsClause(); |
687 | ic_AST = (AST)returnAST; |
688 | classBlock(); |
689 | cb_AST = (AST)returnAST; |
690 | if ( inputState.guessing==0 ) { |
691 | classDefinition_AST = (AST)currentAST.root; |
692 | classDefinition_AST = (AST)astFactory.make( (new ASTArray(7)).add(astFactory.create(CLASS_DEF,"CLASS_DEF")).add(modifiers).add(tmp15_AST).add(tp_AST).add(sc_AST).add(ic_AST).add(cb_AST)); |
693 | currentAST.root = classDefinition_AST; |
694 | currentAST.child = classDefinition_AST!=null &&classDefinition_AST.getFirstChild()!=null ? |
695 | classDefinition_AST.getFirstChild() : classDefinition_AST; |
696 | currentAST.advanceChildToEnd(); |
697 | } |
698 | returnAST = classDefinition_AST; |
699 | } |
700 | |
701 | public final void interfaceDefinition( |
702 | AST modifiers |
703 | ) throws RecognitionException, TokenStreamException { |
704 | |
705 | returnAST = null; |
706 | ASTPair currentAST = new ASTPair(); |
707 | AST interfaceDefinition_AST = null; |
708 | AST tp_AST = null; |
709 | AST ie_AST = null; |
710 | AST ib_AST = null; |
711 | |
712 | match(LITERAL_interface); |
713 | AST tmp17_AST = null; |
714 | tmp17_AST = astFactory.create(LT(1)); |
715 | match(IDENT); |
716 | { |
717 | switch ( LA(1)) { |
718 | case LT: |
719 | { |
720 | typeParameters(); |
721 | tp_AST = (AST)returnAST; |
722 | break; |
723 | } |
724 | case LITERAL_extends: |
725 | case LCURLY: |
726 | { |
727 | break; |
728 | } |
729 | default: |
730 | { |
731 | throw new NoViableAltException(LT(1), getFilename()); |
732 | } |
733 | } |
734 | } |
735 | interfaceExtends(); |
736 | ie_AST = (AST)returnAST; |
737 | interfaceBlock(); |
738 | ib_AST = (AST)returnAST; |
739 | if ( inputState.guessing==0 ) { |
740 | interfaceDefinition_AST = (AST)currentAST.root; |
741 | interfaceDefinition_AST = (AST)astFactory.make( (new ASTArray(6)).add(astFactory.create(INTERFACE_DEF,"INTERFACE_DEF")).add(modifiers).add(tmp17_AST).add(tp_AST).add(ie_AST).add(ib_AST)); |
742 | currentAST.root = interfaceDefinition_AST; |
743 | currentAST.child = interfaceDefinition_AST!=null &&interfaceDefinition_AST.getFirstChild()!=null ? |
744 | interfaceDefinition_AST.getFirstChild() : interfaceDefinition_AST; |
745 | currentAST.advanceChildToEnd(); |
746 | } |
747 | returnAST = interfaceDefinition_AST; |
748 | } |
749 | |
750 | public final void enumDefinition( |
751 | AST modifiers |
752 | ) throws RecognitionException, TokenStreamException { |
753 | |
754 | returnAST = null; |
755 | ASTPair currentAST = new ASTPair(); |
756 | AST enumDefinition_AST = null; |
757 | AST ic_AST = null; |
758 | AST eb_AST = null; |
759 | |
760 | match(LITERAL_enum); |
761 | AST tmp19_AST = null; |
762 | tmp19_AST = astFactory.create(LT(1)); |
763 | match(IDENT); |
764 | implementsClause(); |
765 | ic_AST = (AST)returnAST; |
766 | enumBlock(); |
767 | eb_AST = (AST)returnAST; |
768 | if ( inputState.guessing==0 ) { |
769 | enumDefinition_AST = (AST)currentAST.root; |
770 | enumDefinition_AST = (AST)astFactory.make( (new ASTArray(5)).add(astFactory.create(ENUM_DEF,"ENUM_DEF")).add(modifiers).add(tmp19_AST).add(ic_AST).add(eb_AST)); |
771 | currentAST.root = enumDefinition_AST; |
772 | currentAST.child = enumDefinition_AST!=null &&enumDefinition_AST.getFirstChild()!=null ? |
773 | enumDefinition_AST.getFirstChild() : enumDefinition_AST; |
774 | currentAST.advanceChildToEnd(); |
775 | } |
776 | returnAST = enumDefinition_AST; |
777 | } |
778 | |
779 | public final void annotationDefinition( |
780 | AST modifiers |
781 | ) throws RecognitionException, TokenStreamException { |
782 | |
783 | returnAST = null; |
784 | ASTPair currentAST = new ASTPair(); |
785 | AST annotationDefinition_AST = null; |
786 | AST ab_AST = null; |
787 | |
788 | AST tmp20_AST = null; |
789 | tmp20_AST = astFactory.create(LT(1)); |
790 | match(AT); |
791 | match(LITERAL_interface); |
792 | AST tmp22_AST = null; |
793 | tmp22_AST = astFactory.create(LT(1)); |
794 | match(IDENT); |
795 | annotationBlock(); |
796 | ab_AST = (AST)returnAST; |
797 | if ( inputState.guessing==0 ) { |
798 | annotationDefinition_AST = (AST)currentAST.root; |
799 | annotationDefinition_AST = (AST)astFactory.make( (new ASTArray(4)).add(astFactory.create(ANNOTATION_DEF,"ANNOTATION_DEF")).add(modifiers).add(tmp22_AST).add(ab_AST)); |
800 | currentAST.root = annotationDefinition_AST; |
801 | currentAST.child = annotationDefinition_AST!=null &&annotationDefinition_AST.getFirstChild()!=null ? |
802 | annotationDefinition_AST.getFirstChild() : annotationDefinition_AST; |
803 | currentAST.advanceChildToEnd(); |
804 | } |
805 | returnAST = annotationDefinition_AST; |
806 | } |
807 | |
808 | public final void declaration() throws RecognitionException, TokenStreamException { |
809 | |
810 | returnAST = null; |
811 | ASTPair currentAST = new ASTPair(); |
812 | AST declaration_AST = null; |
813 | AST m_AST = null; |
814 | AST t_AST = null; |
815 | AST v_AST = null; |
816 | |
817 | modifiers(); |
818 | m_AST = (AST)returnAST; |
819 | typeSpec(false); |
820 | t_AST = (AST)returnAST; |
821 | variableDefinitions(m_AST,t_AST); |
822 | v_AST = (AST)returnAST; |
823 | if ( inputState.guessing==0 ) { |
824 | declaration_AST = (AST)currentAST.root; |
825 | declaration_AST = v_AST; |
826 | currentAST.root = declaration_AST; |
827 | currentAST.child = declaration_AST!=null &&declaration_AST.getFirstChild()!=null ? |
828 | declaration_AST.getFirstChild() : declaration_AST; |
829 | currentAST.advanceChildToEnd(); |
830 | } |
831 | returnAST = declaration_AST; |
832 | } |
833 | |
834 | public final void typeSpec( |
835 | boolean addImagNode |
836 | ) throws RecognitionException, TokenStreamException { |
837 | |
838 | returnAST = null; |
839 | ASTPair currentAST = new ASTPair(); |
840 | AST typeSpec_AST = null; |
841 | |
842 | switch ( LA(1)) { |
843 | case IDENT: |
844 | { |
845 | classTypeSpec(addImagNode); |
846 | astFactory.addASTChild(currentAST, returnAST); |
847 | typeSpec_AST = (AST)currentAST.root; |
848 | break; |
849 | } |
850 | case LITERAL_void: |
851 | case LITERAL_boolean: |
852 | case LITERAL_byte: |
853 | case LITERAL_char: |
854 | case LITERAL_short: |
855 | case LITERAL_int: |
856 | case LITERAL_float: |
857 | case LITERAL_long: |
858 | case LITERAL_double: |
859 | { |
860 | builtInTypeSpec(addImagNode); |
861 | astFactory.addASTChild(currentAST, returnAST); |
862 | typeSpec_AST = (AST)currentAST.root; |
863 | break; |
864 | } |
865 | default: |
866 | { |
867 | throw new NoViableAltException(LT(1), getFilename()); |
868 | } |
869 | } |
870 | returnAST = typeSpec_AST; |
871 | } |
872 | |
873 | public final void variableDefinitions( |
874 | AST mods, AST t |
875 | ) throws RecognitionException, TokenStreamException { |
876 | |
877 | returnAST = null; |
878 | ASTPair currentAST = new ASTPair(); |
879 | AST variableDefinitions_AST = null; |
880 | |
881 | variableDeclarator(getASTFactory().dupTree(mods), |
882 | getASTFactory().dupList(t)); |
883 | astFactory.addASTChild(currentAST, returnAST); |
884 | { |
885 | _loop155: |
886 | do { |
887 | if ((LA(1)==COMMA)) { |
888 | match(COMMA); |
889 | variableDeclarator(getASTFactory().dupTree(mods), |
890 | getASTFactory().dupList(t)); |
891 | astFactory.addASTChild(currentAST, returnAST); |
892 | } |
893 | else { |
894 | break _loop155; |
895 | } |
896 | |
897 | } while (true); |
898 | } |
899 | variableDefinitions_AST = (AST)currentAST.root; |
900 | returnAST = variableDefinitions_AST; |
901 | } |
902 | |
903 | public final void classTypeSpec( |
904 | boolean addImagNode |
905 | ) throws RecognitionException, TokenStreamException { |
906 | |
907 | returnAST = null; |
908 | ASTPair currentAST = new ASTPair(); |
909 | AST classTypeSpec_AST = null; |
910 | Token lb = null; |
911 | AST lb_AST = null; |
912 | |
913 | classOrInterfaceType(false); |
914 | astFactory.addASTChild(currentAST, returnAST); |
915 | { |
916 | _loop18: |
917 | do { |
918 | if ((LA(1)==LBRACK) && (LA(2)==RBRACK)) { |
919 | lb = LT(1); |
920 | lb_AST = astFactory.create(lb); |
921 | astFactory.makeASTRoot(currentAST, lb_AST); |
922 | match(LBRACK); |
923 | if ( inputState.guessing==0 ) { |
924 | lb_AST.setType(ARRAY_DECLARATOR); |
925 | } |
926 | match(RBRACK); |
927 | } |
928 | else { |
929 | break _loop18; |
930 | } |
931 | |
932 | } while (true); |
933 | } |
934 | if ( inputState.guessing==0 ) { |
935 | classTypeSpec_AST = (AST)currentAST.root; |
936 | |
937 | if ( addImagNode ) { |
938 | classTypeSpec_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(TYPE,"TYPE")).add(classTypeSpec_AST)); |
939 | } |
940 | |
941 | currentAST.root = classTypeSpec_AST; |
942 | currentAST.child = classTypeSpec_AST!=null &&classTypeSpec_AST.getFirstChild()!=null ? |
943 | classTypeSpec_AST.getFirstChild() : classTypeSpec_AST; |
944 | currentAST.advanceChildToEnd(); |
945 | } |
946 | classTypeSpec_AST = (AST)currentAST.root; |
947 | returnAST = classTypeSpec_AST; |
948 | } |
949 | |
950 | public final void builtInTypeSpec( |
951 | boolean addImagNode |
952 | ) throws RecognitionException, TokenStreamException { |
953 | |
954 | returnAST = null; |
955 | ASTPair currentAST = new ASTPair(); |
956 | AST builtInTypeSpec_AST = null; |
957 | Token lb = null; |
958 | AST lb_AST = null; |
959 | |
960 | builtInType(); |
961 | astFactory.addASTChild(currentAST, returnAST); |
962 | { |
963 | _loop43: |
964 | do { |
965 | if ((LA(1)==LBRACK)) { |
966 | lb = LT(1); |
967 | lb_AST = astFactory.create(lb); |
968 | astFactory.makeASTRoot(currentAST, lb_AST); |
969 | match(LBRACK); |
970 | if ( inputState.guessing==0 ) { |
971 | lb_AST.setType(ARRAY_DECLARATOR); |
972 | } |
973 | match(RBRACK); |
974 | } |
975 | else { |
976 | break _loop43; |
977 | } |
978 | |
979 | } while (true); |
980 | } |
981 | if ( inputState.guessing==0 ) { |
982 | builtInTypeSpec_AST = (AST)currentAST.root; |
983 | |
984 | if ( addImagNode ) { |
985 | builtInTypeSpec_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(TYPE,"TYPE")).add(builtInTypeSpec_AST)); |
986 | } |
987 | |
988 | currentAST.root = builtInTypeSpec_AST; |
989 | currentAST.child = builtInTypeSpec_AST!=null &&builtInTypeSpec_AST.getFirstChild()!=null ? |
990 | builtInTypeSpec_AST.getFirstChild() : builtInTypeSpec_AST; |
991 | currentAST.advanceChildToEnd(); |
992 | } |
993 | builtInTypeSpec_AST = (AST)currentAST.root; |
994 | returnAST = builtInTypeSpec_AST; |
995 | } |
996 | |
997 | public final void classOrInterfaceType( |
998 | boolean addImagNode |
999 | ) throws RecognitionException, TokenStreamException { |
1000 | |
1001 | returnAST = null; |
1002 | ASTPair currentAST = new ASTPair(); |
1003 | AST classOrInterfaceType_AST = null; |
1004 | |
1005 | AST tmp26_AST = null; |
1006 | tmp26_AST = astFactory.create(LT(1)); |
1007 | astFactory.addASTChild(currentAST, tmp26_AST); |
1008 | match(IDENT); |
1009 | { |
1010 | switch ( LA(1)) { |
1011 | case LT: |
1012 | { |
1013 | typeArguments(); |
1014 | astFactory.addASTChild(currentAST, returnAST); |
1015 | break; |
1016 | } |
1017 | case SEMI: |
1018 | case LBRACK: |
1019 | case RBRACK: |
1020 | case IDENT: |
1021 | case DOT: |
1022 | case QUESTION: |
1023 | case LITERAL_extends: |
1024 | case LITERAL_super: |
1025 | case COMMA: |
1026 | case GT: |
1027 | case SR: |
1028 | case BSR: |
1029 | case LITERAL_void: |
1030 | case LITERAL_boolean: |
1031 | case LITERAL_byte: |
1032 | case LITERAL_char: |
1033 | case LITERAL_short: |
1034 | case LITERAL_int: |
1035 | case LITERAL_float: |
1036 | case LITERAL_long: |
1037 | case LITERAL_double: |
1038 | case LPAREN: |
1039 | case RPAREN: |
1040 | case ASSIGN: |
1041 | case LCURLY: |
1042 | case RCURLY: |
1043 | case BAND: |
1044 | case LITERAL_implements: |
1045 | case LITERAL_this: |
1046 | case TRIPLE_DOT: |
1047 | case COLON: |
1048 | case PLUS_ASSIGN: |
1049 | case MINUS_ASSIGN: |
1050 | case STAR_ASSIGN: |
1051 | case DIV_ASSIGN: |
1052 | case MOD_ASSIGN: |
1053 | case SR_ASSIGN: |
1054 | case BSR_ASSIGN: |
1055 | case SL_ASSIGN: |
1056 | case BAND_ASSIGN: |
1057 | case BXOR_ASSIGN: |
1058 | case BOR_ASSIGN: |
1059 | case LOR: |
1060 | case LAND: |
1061 | case BOR: |
1062 | case BXOR: |
1063 | case NOT_EQUAL: |
1064 | case EQUAL: |
1065 | { |
1066 | break; |
1067 | } |
1068 | default: |
1069 | { |
1070 | throw new NoViableAltException(LT(1), getFilename()); |
1071 | } |
1072 | } |
1073 | } |
1074 | { |
1075 | _loop23: |
1076 | do { |
1077 | if ((LA(1)==DOT) && (LA(2)==IDENT)) { |
1078 | AST tmp27_AST = null; |
1079 | tmp27_AST = astFactory.create(LT(1)); |
1080 | astFactory.makeASTRoot(currentAST, tmp27_AST); |
1081 | match(DOT); |
1082 | AST tmp28_AST = null; |
1083 | tmp28_AST = astFactory.create(LT(1)); |
1084 | astFactory.addASTChild(currentAST, tmp28_AST); |
1085 | match(IDENT); |
1086 | { |
1087 | switch ( LA(1)) { |
1088 | case LT: |
1089 | { |
1090 | typeArguments(); |
1091 | astFactory.addASTChild(currentAST, returnAST); |
1092 | break; |
1093 | } |
1094 | case SEMI: |
1095 | case LBRACK: |
1096 | case RBRACK: |
1097 | case IDENT: |
1098 | case DOT: |
1099 | case QUESTION: |
1100 | case LITERAL_extends: |
1101 | case LITERAL_super: |
1102 | case COMMA: |
1103 | case GT: |
1104 | case SR: |
1105 | case BSR: |
1106 | case LITERAL_void: |
1107 | case LITERAL_boolean: |
1108 | case LITERAL_byte: |
1109 | case LITERAL_char: |
1110 | case LITERAL_short: |
1111 | case LITERAL_int: |
1112 | case LITERAL_float: |
1113 | case LITERAL_long: |
1114 | case LITERAL_double: |
1115 | case LPAREN: |
1116 | case RPAREN: |
1117 | case ASSIGN: |
1118 | case LCURLY: |
1119 | case RCURLY: |
1120 | case BAND: |
1121 | case LITERAL_implements: |
1122 | case LITERAL_this: |
1123 | case TRIPLE_DOT: |
1124 | case COLON: |
1125 | case PLUS_ASSIGN: |
1126 | case MINUS_ASSIGN: |
1127 | case STAR_ASSIGN: |
1128 | case DIV_ASSIGN: |
1129 | case MOD_ASSIGN: |
1130 | case SR_ASSIGN: |
1131 | case BSR_ASSIGN: |
1132 | case SL_ASSIGN: |
1133 | case BAND_ASSIGN: |
1134 | case BXOR_ASSIGN: |
1135 | case BOR_ASSIGN: |
1136 | case LOR: |
1137 | case LAND: |
1138 | case BOR: |
1139 | case BXOR: |
1140 | case NOT_EQUAL: |
1141 | case EQUAL: |
1142 | { |
1143 | break; |
1144 | } |
1145 | default: |
1146 | { |
1147 | throw new NoViableAltException(LT(1), getFilename()); |
1148 | } |
1149 | } |
1150 | } |
1151 | } |
1152 | else { |
1153 | break _loop23; |
1154 | } |
1155 | |
1156 | } while (true); |
1157 | } |
1158 | if ( inputState.guessing==0 ) { |
1159 | classOrInterfaceType_AST = (AST)currentAST.root; |
1160 | |
1161 | if ( addImagNode ) { |
1162 | classOrInterfaceType_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(TYPE,"TYPE")).add(classOrInterfaceType_AST)); |
1163 | } |
1164 | |
1165 | currentAST.root = classOrInterfaceType_AST; |
1166 | currentAST.child = classOrInterfaceType_AST!=null &&classOrInterfaceType_AST.getFirstChild()!=null ? |
1167 | classOrInterfaceType_AST.getFirstChild() : classOrInterfaceType_AST; |
1168 | currentAST.advanceChildToEnd(); |
1169 | } |
1170 | classOrInterfaceType_AST = (AST)currentAST.root; |
1171 | returnAST = classOrInterfaceType_AST; |
1172 | } |
1173 | |
1174 | public final void typeArguments() throws RecognitionException, TokenStreamException { |
1175 | |
1176 | returnAST = null; |
1177 | ASTPair currentAST = new ASTPair(); |
1178 | AST typeArguments_AST = null; |
1179 | int currentLtLevel = 0; |
1180 | |
1181 | if ( inputState.guessing==0 ) { |
1182 | currentLtLevel = ltCounter; |
1183 | } |
1184 | match(LT); |
1185 | if ( inputState.guessing==0 ) { |
1186 | ltCounter++; |
1187 | } |
1188 | typeArgument(); |
1189 | astFactory.addASTChild(currentAST, returnAST); |
1190 | { |
1191 | _loop33: |
1192 | do { |
1193 | if (((LA(1)==COMMA) && (_tokenSet_5.member(LA(2))))&&(inputState.guessing !=0 || ltCounter == currentLtLevel + 1)) { |
1194 | match(COMMA); |
1195 | typeArgument(); |
1196 | astFactory.addASTChild(currentAST, returnAST); |
1197 | } |
1198 | else { |
1199 | break _loop33; |
1200 | } |
1201 | |
1202 | } while (true); |
1203 | } |
1204 | { |
1205 | if (((LA(1) >= GT && LA(1) <= BSR)) && (_tokenSet_6.member(LA(2)))) { |
1206 | typeArgumentsOrParametersEnd(); |
1207 | astFactory.addASTChild(currentAST, returnAST); |
1208 | } |
1209 | else if ((_tokenSet_6.member(LA(1))) && (_tokenSet_7.member(LA(2)))) { |
1210 | } |
1211 | else { |
1212 | throw new NoViableAltException(LT(1), getFilename()); |
1213 | } |
1214 | |
1215 | } |
1216 | if (!((currentLtLevel != 0) || ltCounter == currentLtLevel)) |
1217 | throw new SemanticException("(currentLtLevel != 0) || ltCounter == currentLtLevel"); |
1218 | if ( inputState.guessing==0 ) { |
1219 | typeArguments_AST = (AST)currentAST.root; |
1220 | typeArguments_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(TYPE_ARGUMENTS,"TYPE_ARGUMENTS")).add(typeArguments_AST)); |
1221 | currentAST.root = typeArguments_AST; |
1222 | currentAST.child = typeArguments_AST!=null &&typeArguments_AST.getFirstChild()!=null ? |
1223 | typeArguments_AST.getFirstChild() : typeArguments_AST; |
1224 | currentAST.advanceChildToEnd(); |
1225 | } |
1226 | typeArguments_AST = (AST)currentAST.root; |
1227 | returnAST = typeArguments_AST; |
1228 | } |
1229 | |
1230 | public final void typeArgumentSpec() throws RecognitionException, TokenStreamException { |
1231 | |
1232 | returnAST = null; |
1233 | ASTPair currentAST = new ASTPair(); |
1234 | AST typeArgumentSpec_AST = null; |
1235 | |
1236 | switch ( LA(1)) { |
1237 | case IDENT: |
1238 | { |
1239 | classTypeSpec(true); |
1240 | astFactory.addASTChild(currentAST, returnAST); |
1241 | typeArgumentSpec_AST = (AST)currentAST.root; |
1242 | break; |
1243 | } |
1244 | case LITERAL_void: |
1245 | case LITERAL_boolean: |
1246 | case LITERAL_byte: |
1247 | case LITERAL_char: |
1248 | case LITERAL_short: |
1249 | case LITERAL_int: |
1250 | case LITERAL_float: |
1251 | case LITERAL_long: |
1252 | case LITERAL_double: |
1253 | { |
1254 | builtInTypeArraySpec(true); |
1255 | astFactory.addASTChild(currentAST, returnAST); |
1256 | typeArgumentSpec_AST = (AST)currentAST.root; |
1257 | break; |
1258 | } |
1259 | default: |
1260 | { |
1261 | throw new NoViableAltException(LT(1), getFilename()); |
1262 | } |
1263 | } |
1264 | returnAST = typeArgumentSpec_AST; |
1265 | } |
1266 | |
1267 | public final void builtInTypeArraySpec( |
1268 | boolean addImagNode |
1269 | ) throws RecognitionException, TokenStreamException { |
1270 | |
1271 | returnAST = null; |
1272 | ASTPair currentAST = new ASTPair(); |
1273 | AST builtInTypeArraySpec_AST = null; |
1274 | Token lb = null; |
1275 | AST lb_AST = null; |
1276 | |
1277 | builtInType(); |
1278 | astFactory.addASTChild(currentAST, returnAST); |
1279 | { |
1280 | int _cnt40=0; |
1281 | _loop40: |
1282 | do { |
1283 | if ((LA(1)==LBRACK) && (LA(2)==RBRACK)) { |
1284 | lb = LT(1); |
1285 | lb_AST = astFactory.create(lb); |
1286 | astFactory.makeASTRoot(currentAST, lb_AST); |
1287 | match(LBRACK); |
1288 | if ( inputState.guessing==0 ) { |
1289 | lb_AST.setType(ARRAY_DECLARATOR); |
1290 | } |
1291 | match(RBRACK); |
1292 | } |
1293 | else { |
1294 | if ( _cnt40>=1 ) { break _loop40; } else {throw new NoViableAltException(LT(1), getFilename());} |
1295 | } |
1296 | |
1297 | _cnt40++; |
1298 | } while (true); |
1299 | } |
1300 | if ( inputState.guessing==0 ) { |
1301 | builtInTypeArraySpec_AST = (AST)currentAST.root; |
1302 | |
1303 | if ( addImagNode ) { |
1304 | builtInTypeArraySpec_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(TYPE,"TYPE")).add(builtInTypeArraySpec_AST)); |
1305 | } |
1306 | |
1307 | currentAST.root = builtInTypeArraySpec_AST; |
1308 | currentAST.child = builtInTypeArraySpec_AST!=null &&builtInTypeArraySpec_AST.getFirstChild()!=null ? |
1309 | builtInTypeArraySpec_AST.getFirstChild() : builtInTypeArraySpec_AST; |
1310 | currentAST.advanceChildToEnd(); |
1311 | } |
1312 | builtInTypeArraySpec_AST = (AST)currentAST.root; |
1313 | returnAST = builtInTypeArraySpec_AST; |
1314 | } |
1315 | |
1316 | public final void typeArgument() throws RecognitionException, TokenStreamException { |
1317 | |
1318 | returnAST = null; |
1319 | ASTPair currentAST = new ASTPair(); |
1320 | AST typeArgument_AST = null; |
1321 | |
1322 | { |
1323 | switch ( LA(1)) { |
1324 | case IDENT: |
1325 | case LITERAL_void: |
1326 | case LITERAL_boolean: |
1327 | case LITERAL_byte: |
1328 | case LITERAL_char: |
1329 | case LITERAL_short: |
1330 | case LITERAL_int: |
1331 | case LITERAL_float: |
1332 | case LITERAL_long: |
1333 | case LITERAL_double: |
1334 | { |
1335 | typeArgumentSpec(); |
1336 | astFactory.addASTChild(currentAST, returnAST); |
1337 | break; |
1338 | } |
1339 | case QUESTION: |
1340 | { |
1341 | wildcardType(); |
1342 | astFactory.addASTChild(currentAST, returnAST); |
1343 | break; |
1344 | } |
1345 | default: |
1346 | { |
1347 | throw new NoViableAltException(LT(1), getFilename()); |
1348 | } |
1349 | } |
1350 | } |
1351 | if ( inputState.guessing==0 ) { |
1352 | typeArgument_AST = (AST)currentAST.root; |
1353 | typeArgument_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(TYPE_ARGUMENT,"TYPE_ARGUMENT")).add(typeArgument_AST)); |
1354 | currentAST.root = typeArgument_AST; |
1355 | currentAST.child = typeArgument_AST!=null &&typeArgument_AST.getFirstChild()!=null ? |
1356 | typeArgument_AST.getFirstChild() : typeArgument_AST; |
1357 | currentAST.advanceChildToEnd(); |
1358 | } |
1359 | typeArgument_AST = (AST)currentAST.root; |
1360 | returnAST = typeArgument_AST; |
1361 | } |
1362 | |
1363 | public final void wildcardType() throws RecognitionException, TokenStreamException { |
1364 | |
1365 | returnAST = null; |
1366 | ASTPair currentAST = new ASTPair(); |
1367 | AST wildcardType_AST = null; |
1368 | Token q = null; |
1369 | AST q_AST = null; |
1370 | |
1371 | q = LT(1); |
1372 | q_AST = astFactory.create(q); |
1373 | astFactory.makeASTRoot(currentAST, q_AST); |
1374 | match(QUESTION); |
1375 | if ( inputState.guessing==0 ) { |
1376 | q_AST.setType(WILDCARD_TYPE); |
1377 | } |
1378 | { |
1379 | boolean synPredMatched30 = false; |
1380 | if (((LA(1)==LITERAL_extends||LA(1)==LITERAL_super) && (LA(2)==IDENT))) { |
1381 | int _m30 = mark(); |
1382 | synPredMatched30 = true; |
1383 | inputState.guessing++; |
1384 | try { |
1385 | { |
1386 | switch ( LA(1)) { |
1387 | case LITERAL_extends: |
1388 | { |
1389 | match(LITERAL_extends); |
1390 | break; |
1391 | } |
1392 | case LITERAL_super: |
1393 | { |
1394 | match(LITERAL_super); |
1395 | break; |
1396 | } |
1397 | default: |
1398 | { |
1399 | throw new NoViableAltException(LT(1), getFilename()); |
1400 | } |
1401 | } |
1402 | } |
1403 | } |
1404 | catch (RecognitionException pe) { |
1405 | synPredMatched30 = false; |
1406 | } |
1407 | rewind(_m30); |
1408 | inputState.guessing--; |
1409 | } |
1410 | if ( synPredMatched30 ) { |
1411 | typeArgumentBounds(); |
1412 | astFactory.addASTChild(currentAST, returnAST); |
1413 | } |
1414 | else if ((_tokenSet_6.member(LA(1))) && (_tokenSet_7.member(LA(2)))) { |
1415 | } |
1416 | else { |
1417 | throw new NoViableAltException(LT(1), getFilename()); |
1418 | } |
1419 | |
1420 | } |
1421 | wildcardType_AST = (AST)currentAST.root; |
1422 | returnAST = wildcardType_AST; |
1423 | } |
1424 | |
1425 | public final void typeArgumentBounds() throws RecognitionException, TokenStreamException { |
1426 | |
1427 | returnAST = null; |
1428 | ASTPair currentAST = new ASTPair(); |
1429 | AST typeArgumentBounds_AST = null; |
1430 | boolean isUpperBounds = false; |
1431 | |
1432 | { |
1433 | switch ( LA(1)) { |
1434 | case LITERAL_extends: |
1435 | { |
1436 | match(LITERAL_extends); |
1437 | if ( inputState.guessing==0 ) { |
1438 | isUpperBounds=true; |
1439 | } |
1440 | break; |
1441 | } |
1442 | case LITERAL_super: |
1443 | { |
1444 | match(LITERAL_super); |
1445 | break; |
1446 | } |
1447 | default: |
1448 | { |
1449 | throw new NoViableAltException(LT(1), getFilename()); |
1450 | } |
1451 | } |
1452 | } |
1453 | classOrInterfaceType(false); |
1454 | astFactory.addASTChild(currentAST, returnAST); |
1455 | if ( inputState.guessing==0 ) { |
1456 | typeArgumentBounds_AST = (AST)currentAST.root; |
1457 | |
1458 | if (isUpperBounds) |
1459 | { |
1460 | typeArgumentBounds_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(TYPE_UPPER_BOUNDS,"TYPE_UPPER_BOUNDS")).add(typeArgumentBounds_AST)); |
1461 | } |
1462 | else |
1463 | { |
1464 | typeArgumentBounds_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(TYPE_LOWER_BOUNDS,"TYPE_LOWER_BOUNDS")).add(typeArgumentBounds_AST)); |
1465 | } |
1466 | |
1467 | currentAST.root = typeArgumentBounds_AST; |
1468 | currentAST.child = typeArgumentBounds_AST!=null &&typeArgumentBounds_AST.getFirstChild()!=null ? |
1469 | typeArgumentBounds_AST.getFirstChild() : typeArgumentBounds_AST; |
1470 | currentAST.advanceChildToEnd(); |
1471 | } |
1472 | typeArgumentBounds_AST = (AST)currentAST.root; |
1473 | returnAST = typeArgumentBounds_AST; |
1474 | } |
1475 | |
1476 | protected final void typeArgumentsOrParametersEnd() throws RecognitionException, TokenStreamException { |
1477 | |
1478 | returnAST = null; |
1479 | ASTPair currentAST = new ASTPair(); |
1480 | AST typeArgumentsOrParametersEnd_AST = null; |
1481 | |
1482 | switch ( LA(1)) { |
1483 | case GT: |
1484 | { |
1485 | match(GT); |
1486 | if ( inputState.guessing==0 ) { |
1487 | ltCounter-=1; |
1488 | } |
1489 | typeArgumentsOrParametersEnd_AST = (AST)currentAST.root; |
1490 | break; |
1491 | } |
1492 | case SR: |
1493 | { |
1494 | match(SR); |
1495 | if ( inputState.guessing==0 ) { |
1496 | ltCounter-=2; |
1497 | } |
1498 | typeArgumentsOrParametersEnd_AST = (AST)currentAST.root; |
1499 | break; |
1500 | } |
1501 | case BSR: |
1502 | { |
1503 | match(BSR); |
1504 | if ( inputState.guessing==0 ) { |
1505 | ltCounter-=3; |
1506 | } |
1507 | typeArgumentsOrParametersEnd_AST = (AST)currentAST.root; |
1508 | break; |
1509 | } |
1510 | default: |
1511 | { |
1512 | throw new NoViableAltException(LT(1), getFilename()); |
1513 | } |
1514 | } |
1515 | returnAST = typeArgumentsOrParametersEnd_AST; |
1516 | } |
1517 | |
1518 | public final void builtInType() throws RecognitionException, TokenStreamException { |
1519 | |
1520 | returnAST = null; |
1521 | ASTPair currentAST = new ASTPair(); |
1522 | AST builtInType_AST = null; |
1523 | |
1524 | switch ( LA(1)) { |
1525 | case LITERAL_void: |
1526 | { |
1527 | AST tmp37_AST = null; |
1528 | tmp37_AST = astFactory.create(LT(1)); |
1529 | astFactory.addASTChild(currentAST, tmp37_AST); |
1530 | match(LITERAL_void); |
1531 | builtInType_AST = (AST)currentAST.root; |
1532 | break; |
1533 | } |
1534 | case LITERAL_boolean: |
1535 | { |
1536 | AST tmp38_AST = null; |
1537 | tmp38_AST = astFactory.create(LT(1)); |
1538 | astFactory.addASTChild(currentAST, tmp38_AST); |
1539 | match(LITERAL_boolean); |
1540 | builtInType_AST = (AST)currentAST.root; |
1541 | break; |
1542 | } |
1543 | case LITERAL_byte: |
1544 | { |
1545 | AST tmp39_AST = null; |
1546 | tmp39_AST = astFactory.create(LT(1)); |
1547 | astFactory.addASTChild(currentAST, tmp39_AST); |
1548 | match(LITERAL_byte); |
1549 | builtInType_AST = (AST)currentAST.root; |
1550 | break; |
1551 | } |
1552 | case LITERAL_char: |
1553 | { |
1554 | AST tmp40_AST = null; |
1555 | tmp40_AST = astFactory.create(LT(1)); |
1556 | astFactory.addASTChild(currentAST, tmp40_AST); |
1557 | match(LITERAL_char); |
1558 | builtInType_AST = (AST)currentAST.root; |
1559 | break; |
1560 | } |
1561 | case LITERAL_short: |
1562 | { |
1563 | AST tmp41_AST = null; |
1564 | tmp41_AST = astFactory.create(LT(1)); |
1565 | astFactory.addASTChild(currentAST, tmp41_AST); |
1566 | match(LITERAL_short); |
1567 | builtInType_AST = (AST)currentAST.root; |
1568 | break; |
1569 | } |
1570 | case LITERAL_int: |
1571 | { |
1572 | AST tmp42_AST = null; |
1573 | tmp42_AST = astFactory.create(LT(1)); |
1574 | astFactory.addASTChild(currentAST, tmp42_AST); |
1575 | match(LITERAL_int); |
1576 | builtInType_AST = (AST)currentAST.root; |
1577 | break; |
1578 | } |
1579 | case LITERAL_float: |
1580 | { |
1581 | AST tmp43_AST = null; |
1582 | tmp43_AST = astFactory.create(LT(1)); |
1583 | astFactory.addASTChild(currentAST, tmp43_AST); |
1584 | match(LITERAL_float); |
1585 | builtInType_AST = (AST)currentAST.root; |
1586 | break; |
1587 | } |
1588 | case LITERAL_long: |
1589 | { |
1590 | AST tmp44_AST = null; |
1591 | tmp44_AST = astFactory.create(LT(1)); |
1592 | astFactory.addASTChild(currentAST, tmp44_AST); |
1593 | match(LITERAL_long); |
1594 | builtInType_AST = (AST)currentAST.root; |
1595 | break; |
1596 | } |
1597 | case LITERAL_double: |
1598 | { |
1599 | AST tmp45_AST = null; |
1600 | tmp45_AST = astFactory.create(LT(1)); |
1601 | astFactory.addASTChild(currentAST, tmp45_AST); |
1602 | match(LITERAL_double); |
1603 | builtInType_AST = (AST)currentAST.root; |
1604 | break; |
1605 | } |
1606 | default: |
1607 | { |
1608 | throw new NoViableAltException(LT(1), getFilename()); |
1609 | } |
1610 | } |
1611 | returnAST = builtInType_AST; |
1612 | } |
1613 | |
1614 | public final void type() throws RecognitionException, TokenStreamException { |
1615 | |
1616 | returnAST = null; |
1617 | ASTPair currentAST = new ASTPair(); |
1618 | AST type_AST = null; |
1619 | |
1620 | switch ( LA(1)) { |
1621 | case IDENT: |
1622 | { |
1623 | classOrInterfaceType(false); |
1624 | astFactory.addASTChild(currentAST, returnAST); |
1625 | type_AST = (AST)currentAST.root; |
1626 | break; |
1627 | } |
1628 | case LITERAL_void: |
1629 | case LITERAL_boolean: |
1630 | case LITERAL_byte: |
1631 | case LITERAL_char: |
1632 | case LITERAL_short: |
1633 | case LITERAL_int: |
1634 | case LITERAL_float: |
1635 | case LITERAL_long: |
1636 | case LITERAL_double: |
1637 | { |
1638 | builtInType(); |
1639 | astFactory.addASTChild(currentAST, returnAST); |
1640 | type_AST = (AST)currentAST.root; |
1641 | break; |
1642 | } |
1643 | default: |
1644 | { |
1645 | throw new NoViableAltException(LT(1), getFilename()); |
1646 | } |
1647 | } |
1648 | returnAST = type_AST; |
1649 | } |
1650 | |
1651 | public final void modifier() throws RecognitionException, TokenStreamException { |
1652 | |
1653 | returnAST = null; |
1654 | ASTPair currentAST = new ASTPair(); |
1655 | AST modifier_AST = null; |
1656 | |
1657 | switch ( LA(1)) { |
1658 | case LITERAL_private: |
1659 | { |
1660 | AST tmp46_AST = null; |
1661 | tmp46_AST = astFactory.create(LT(1)); |
1662 | astFactory.addASTChild(currentAST, tmp46_AST); |
1663 | match(LITERAL_private); |
1664 | modifier_AST = (AST)currentAST.root; |
1665 | break; |
1666 | } |
1667 | case LITERAL_public: |
1668 | { |
1669 | AST tmp47_AST = null; |
1670 | tmp47_AST = astFactory.create(LT(1)); |
1671 | astFactory.addASTChild(currentAST, tmp47_AST); |
1672 | match(LITERAL_public); |
1673 | modifier_AST = (AST)currentAST.root; |
1674 | break; |
1675 | } |
1676 | case LITERAL_protected: |
1677 | { |
1678 | AST tmp48_AST = null; |
1679 | tmp48_AST = astFactory.create(LT(1)); |
1680 | astFactory.addASTChild(currentAST, tmp48_AST); |
1681 | match(LITERAL_protected); |
1682 | modifier_AST = (AST)currentAST.root; |
1683 | break; |
1684 | } |
1685 | case LITERAL_static: |
1686 | { |
1687 | AST tmp49_AST = null; |
1688 | tmp49_AST = astFactory.create(LT(1)); |
1689 | astFactory.addASTChild(currentAST, tmp49_AST); |
1690 | match(LITERAL_static); |
1691 | modifier_AST = (AST)currentAST.root; |
1692 | break; |
1693 | } |
1694 | case LITERAL_transient: |
1695 | { |
1696 | AST tmp50_AST = null; |
1697 | tmp50_AST = astFactory.create(LT(1)); |
1698 | astFactory.addASTChild(currentAST, tmp50_AST); |
1699 | match(LITERAL_transient); |
1700 | modifier_AST = (AST)currentAST.root; |
1701 | break; |
1702 | } |
1703 | case FINAL: |
1704 | { |
1705 | AST tmp51_AST = null; |
1706 | tmp51_AST = astFactory.create(LT(1)); |
1707 | astFactory.addASTChild(currentAST, tmp51_AST); |
1708 | match(FINAL); |
1709 | modifier_AST = (AST)currentAST.root; |
1710 | break; |
1711 | } |
1712 | case ABSTRACT: |
1713 | { |
1714 | AST tmp52_AST = null; |
1715 | tmp52_AST = astFactory.create(LT(1)); |
1716 | astFactory.addASTChild(currentAST, tmp52_AST); |
1717 | match(ABSTRACT); |
1718 | modifier_AST = (AST)currentAST.root; |
1719 | break; |
1720 | } |
1721 | case LITERAL_native: |
1722 | { |
1723 | AST tmp53_AST = null; |
1724 | tmp53_AST = astFactory.create(LT(1)); |
1725 | astFactory.addASTChild(currentAST, tmp53_AST); |
1726 | match(LITERAL_native); |
1727 | modifier_AST = (AST)currentAST.root; |
1728 | break; |
1729 | } |
1730 | case LITERAL_threadsafe: |
1731 | { |
1732 | AST tmp54_AST = null; |
1733 | tmp54_AST = astFactory.create(LT(1)); |
1734 | astFactory.addASTChild(currentAST, tmp54_AST); |
1735 | match(LITERAL_threadsafe); |
1736 | modifier_AST = (AST)currentAST.root; |
1737 | break; |
1738 | } |
1739 | case LITERAL_synchronized: |
1740 | { |
1741 | AST tmp55_AST = null; |
1742 | tmp55_AST = astFactory.create(LT(1)); |
1743 | astFactory.addASTChild(currentAST, tmp55_AST); |
1744 | match(LITERAL_synchronized); |
1745 | modifier_AST = (AST)currentAST.root; |
1746 | break; |
1747 | } |
1748 | case LITERAL_volatile: |
1749 | { |
1750 | AST tmp56_AST = null; |
1751 | tmp56_AST = astFactory.create(LT(1)); |
1752 | astFactory.addASTChild(currentAST, tmp56_AST); |
1753 | match(LITERAL_volatile); |
1754 | modifier_AST = (AST)currentAST.root; |
1755 | break; |
1756 | } |
1757 | case STRICTFP: |
1758 | { |
1759 | AST tmp57_AST = null; |
1760 | tmp57_AST = astFactory.create(LT(1)); |
1761 | astFactory.addASTChild(currentAST, tmp57_AST); |
1762 | match(STRICTFP); |
1763 | modifier_AST = (AST)currentAST.root; |
1764 | break; |
1765 | } |
1766 | default: |
1767 | { |
1768 | throw new NoViableAltException(LT(1), getFilename()); |
1769 | } |
1770 | } |
1771 | returnAST = modifier_AST; |
1772 | } |
1773 | |
1774 | public final void annotation() throws RecognitionException, TokenStreamException { |
1775 | |
1776 | returnAST = null; |
1777 | ASTPair currentAST = new ASTPair(); |
1778 | AST annotation_AST = null; |
1779 | AST i_AST = null; |
1780 | AST args_AST = null; |
1781 | |
1782 | match(AT); |
1783 | identifier(); |
1784 | i_AST = (AST)returnAST; |
1785 | { |
1786 | switch ( LA(1)) { |
1787 | case LPAREN: |
1788 | { |
1789 | match(LPAREN); |
1790 | { |
1791 | switch ( LA(1)) { |
1792 | case IDENT: |
1793 | case LITERAL_super: |
1794 | case LT: |
1795 | case LITERAL_void: |
1796 | case LITERAL_boolean: |
1797 | case LITERAL_byte: |
1798 | case LITERAL_char: |
1799 | case LITERAL_short: |
1800 | case LITERAL_int: |
1801 | case LITERAL_float: |
1802 | case LITERAL_long: |
1803 | case LITERAL_double: |
1804 | case AT: |
1805 | case LPAREN: |
1806 | case LCURLY: |
1807 | case LITERAL_this: |
1808 | case PLUS: |
1809 | case MINUS: |
1810 | case INC: |
1811 | case DEC: |
1812 | case BNOT: |
1813 | case LNOT: |
1814 | case LITERAL_true: |
1815 | case LITERAL_false: |
1816 | case LITERAL_null: |
1817 | case LITERAL_new: |
1818 | case NUM_INT: |
1819 | case CHAR_LITERAL: |
1820 | case STRING_LITERAL: |
1821 | case NUM_FLOAT: |
1822 | case NUM_LONG: |
1823 | case NUM_DOUBLE: |
1824 | { |
1825 | annotationArguments(); |
1826 | args_AST = (AST)returnAST; |
1827 | break; |
1828 | } |
1829 | case RPAREN: |
1830 | { |
1831 | break; |
1832 | } |
1833 | default: |
1834 | { |
1835 | throw new NoViableAltException(LT(1), getFilename()); |
1836 | } |
1837 | } |
1838 | } |
1839 | match(RPAREN); |
1840 | break; |
1841 | } |
1842 | case FINAL: |
1843 | case ABSTRACT: |
1844 | case STRICTFP: |
1845 | case LITERAL_package: |
1846 | case SEMI: |
1847 | case LITERAL_static: |
1848 | case IDENT: |
1849 | case LT: |
1850 | case COMMA: |
1851 | case LITERAL_void: |
1852 | case LITERAL_boolean: |
1853 | case LITERAL_byte: |
1854 | case LITERAL_char: |
1855 | case LITERAL_short: |
1856 | case LITERAL_int: |
1857 | case LITERAL_float: |
1858 | case LITERAL_long: |
1859 | case LITERAL_double: |
1860 | case LITERAL_private: |
1861 | case LITERAL_public: |
1862 | case LITERAL_protected: |
1863 | case LITERAL_transient: |
1864 | case LITERAL_native: |
1865 | case LITERAL_threadsafe: |
1866 | case LITERAL_synchronized: |
1867 | case LITERAL_volatile: |
1868 | case AT: |
1869 | case RPAREN: |
1870 | case RCURLY: |
1871 | case LITERAL_class: |
1872 | case LITERAL_interface: |
1873 | case LITERAL_enum: |
1874 | { |
1875 | break; |
1876 | } |
1877 | default: |
1878 | { |
1879 | throw new NoViableAltException(LT(1), getFilename()); |
1880 | } |
1881 | } |
1882 | } |
1883 | if ( inputState.guessing==0 ) { |
1884 | annotation_AST = (AST)currentAST.root; |
1885 | annotation_AST = (AST)astFactory.make( (new ASTArray(3)).add(astFactory.create(ANNOTATION,"ANNOTATION")).add(i_AST).add(args_AST)); |
1886 | currentAST.root = annotation_AST; |
1887 | currentAST.child = annotation_AST!=null &&annotation_AST.getFirstChild()!=null ? |
1888 | annotation_AST.getFirstChild() : annotation_AST; |
1889 | currentAST.advanceChildToEnd(); |
1890 | } |
1891 | returnAST = annotation_AST; |
1892 | } |
1893 | |
1894 | public final void annotationArguments() throws RecognitionException, TokenStreamException { |
1895 | |
1896 | returnAST = null; |
1897 | ASTPair currentAST = new ASTPair(); |
1898 | AST annotationArguments_AST = null; |
1899 | |
1900 | if ((_tokenSet_8.member(LA(1))) && (_tokenSet_9.member(LA(2)))) { |
1901 | annotationMemberValueInitializer(); |
1902 | astFactory.addASTChild(currentAST, returnAST); |
1903 | annotationArguments_AST = (AST)currentAST.root; |
1904 | } |
1905 | else if ((LA(1)==IDENT) && (LA(2)==ASSIGN)) { |
1906 | anntotationMemberValuePairs(); |
1907 | astFactory.addASTChild(currentAST, returnAST); |
1908 | annotationArguments_AST = (AST)currentAST.root; |
1909 | } |
1910 | else { |
1911 | throw new NoViableAltException(LT(1), getFilename()); |
1912 | } |
1913 | |
1914 | returnAST = annotationArguments_AST; |
1915 | } |
1916 | |
1917 | public final void annotationMemberValueInitializer() throws RecognitionException, TokenStreamException { |
1918 | |
1919 | returnAST = null; |
1920 | ASTPair currentAST = new ASTPair(); |
1921 | AST annotationMemberValueInitializer_AST = null; |
1922 | |
1923 | switch ( LA(1)) { |
1924 | case IDENT: |
1925 | case LITERAL_super: |
1926 | case LT: |
1927 | case LITERAL_void: |
1928 | case LITERAL_boolean: |
1929 | case LITERAL_byte: |
1930 | case LITERAL_char: |
1931 | case LITERAL_short: |
1932 | case LITERAL_int: |
1933 | case LITERAL_float: |
1934 | case LITERAL_long: |
1935 | case LITERAL_double: |
1936 | case LPAREN: |
1937 | case LITERAL_this: |
1938 | case PLUS: |
1939 | case MINUS: |
1940 | case INC: |
1941 | case DEC: |
1942 | case BNOT: |
1943 | case LNOT: |
1944 | case LITERAL_true: |
1945 | case LITERAL_false: |
1946 | case LITERAL_null: |
1947 | case LITERAL_new: |
1948 | case NUM_INT: |
1949 | case CHAR_LITERAL: |
1950 | case STRING_LITERAL: |
1951 | case NUM_FLOAT: |
1952 | case NUM_LONG: |
1953 | case NUM_DOUBLE: |
1954 | { |
1955 | conditionalExpression(); |
1956 | astFactory.addASTChild(currentAST, returnAST); |
1957 | annotationMemberValueInitializer_AST = (AST)currentAST.root; |
1958 | break; |
1959 | } |
1960 | case AT: |
1961 | { |
1962 | annotation(); |
1963 | astFactory.addASTChild(currentAST, returnAST); |
1964 | annotationMemberValueInitializer_AST = (AST)currentAST.root; |
1965 | break; |
1966 | } |
1967 | case LCURLY: |
1968 | { |
1969 | annotationMemberArrayInitializer(); |
1970 | astFactory.addASTChild(currentAST, returnAST); |
1971 | annotationMemberValueInitializer_AST = (AST)currentAST.root; |
1972 | break; |
1973 | } |
1974 | default: |
1975 | { |
1976 | throw new NoViableAltException(LT(1), getFilename()); |
1977 | } |
1978 | } |
1979 | returnAST = annotationMemberValueInitializer_AST; |
1980 | } |
1981 | |
1982 | public final void anntotationMemberValuePairs() throws RecognitionException, TokenStreamException { |
1983 | |
1984 | returnAST = null; |
1985 | ASTPair currentAST = new ASTPair(); |
1986 | AST anntotationMemberValuePairs_AST = null; |
1987 | |
1988 | annotationMemberValuePair(); |
1989 | astFactory.addASTChild(currentAST, returnAST); |
1990 | { |
1991 | _loop66: |
1992 | do { |
1993 | if ((LA(1)==COMMA)) { |
1994 | match(COMMA); |
1995 | annotationMemberValuePair(); |
1996 | astFactory.addASTChild(currentAST, returnAST); |
1997 | } |
1998 | else { |
1999 | break _loop66; |
2000 | } |
2001 | |
2002 | } while (true); |
2003 | } |
2004 | anntotationMemberValuePairs_AST = (AST)currentAST.root; |
2005 | returnAST = anntotationMemberValuePairs_AST; |
2006 | } |
2007 | |
2008 | public final void annotationMemberValuePair() throws RecognitionException, TokenStreamException { |
2009 | |
2010 | returnAST = null; |
2011 | ASTPair currentAST = new ASTPair(); |
2012 | AST annotationMemberValuePair_AST = null; |
2013 | Token i = null; |
2014 | AST i_AST = null; |
2015 | AST v_AST = null; |
2016 | |
2017 | i = LT(1); |
2018 | i_AST = astFactory.create(i); |
2019 | match(IDENT); |
2020 | match(ASSIGN); |
2021 | annotationMemberValueInitializer(); |
2022 | v_AST = (AST)returnAST; |
2023 | if ( inputState.guessing==0 ) { |
2024 | annotationMemberValuePair_AST = (AST)currentAST.root; |
2025 | annotationMemberValuePair_AST = (AST)astFactory.make( (new ASTArray(3)).add(astFactory.create(ANNOTATION_MEMBER_VALUE_PAIR,"ANNOTATION_MEMBER_VALUE_PAIR")).add(i_AST).add(v_AST)); |
2026 | currentAST.root = annotationMemberValuePair_AST; |
2027 | currentAST.child = annotationMemberValuePair_AST!=null &&annotationMemberValuePair_AST.getFirstChild()!=null ? |
2028 | annotationMemberValuePair_AST.getFirstChild() : annotationMemberValuePair_AST; |
2029 | currentAST.advanceChildToEnd(); |
2030 | } |
2031 | returnAST = annotationMemberValuePair_AST; |
2032 | } |
2033 | |
2034 | public final void conditionalExpression() throws RecognitionException, TokenStreamException { |
2035 | |
2036 | returnAST = null; |
2037 | ASTPair currentAST = new ASTPair(); |
2038 | AST conditionalExpression_AST = null; |
2039 | |
2040 | logicalOrExpression(); |
2041 | astFactory.addASTChild(currentAST, returnAST); |
2042 | { |
2043 | switch ( LA(1)) { |
2044 | case QUESTION: |
2045 | { |
2046 | AST tmp63_AST = null; |
2047 | tmp63_AST = astFactory.create(LT(1)); |
2048 | astFactory.makeASTRoot(currentAST, tmp63_AST); |
2049 | match(QUESTION); |
2050 | assignmentExpression(); |
2051 | astFactory.addASTChild(currentAST, returnAST); |
2052 | match(COLON); |
2053 | conditionalExpression(); |
2054 | astFactory.addASTChild(currentAST, returnAST); |
2055 | break; |
2056 | } |
2057 | case SEMI: |
2058 | case RBRACK: |
2059 | case COMMA: |
2060 | case RPAREN: |
2061 | case ASSIGN: |
2062 | case RCURLY: |
2063 | case COLON: |
2064 | case PLUS_ASSIGN: |
2065 | case MINUS_ASSIGN: |
2066 | case STAR_ASSIGN: |
2067 | case DIV_ASSIGN: |
2068 | case MOD_ASSIGN: |
2069 | case SR_ASSIGN: |
2070 | case BSR_ASSIGN: |
2071 | case SL_ASSIGN: |
2072 | case BAND_ASSIGN: |
2073 | case BXOR_ASSIGN: |
2074 | case BOR_ASSIGN: |
2075 | { |
2076 | break; |
2077 | } |
2078 | default: |
2079 | { |
2080 | throw new NoViableAltException(LT(1), getFilename()); |
2081 | } |
2082 | } |
2083 | } |
2084 | conditionalExpression_AST = (AST)currentAST.root; |
2085 | returnAST = conditionalExpression_AST; |
2086 | } |
2087 | |
2088 | public final void annotationMemberArrayInitializer() throws RecognitionException, TokenStreamException { |
2089 | |
2090 | returnAST = null; |
2091 | ASTPair currentAST = new ASTPair(); |
2092 | AST annotationMemberArrayInitializer_AST = null; |
2093 | Token lc = null; |
2094 | AST lc_AST = null; |
2095 | |
2096 | lc = LT(1); |
2097 | lc_AST = astFactory.create(lc); |
2098 | astFactory.makeASTRoot(currentAST, lc_AST); |
2099 | match(LCURLY); |
2100 | if ( inputState.guessing==0 ) { |
2101 | lc_AST.setType(ANNOTATION_ARRAY_INIT); |
2102 | } |
2103 | { |
2104 | switch ( LA(1)) { |
2105 | case IDENT: |
2106 | case LITERAL_super: |
2107 | case LT: |
2108 | case LITERAL_void: |
2109 | case LITERAL_boolean: |
2110 | case LITERAL_byte: |
2111 | case LITERAL_char: |
2112 | case LITERAL_short: |
2113 | case LITERAL_int: |
2114 | case LITERAL_float: |
2115 | case LITERAL_long: |
2116 | case LITERAL_double: |
2117 | case AT: |
2118 | case LPAREN: |
2119 | case LITERAL_this: |
2120 | case PLUS: |
2121 | case MINUS: |
2122 | case INC: |
2123 | case DEC: |
2124 | case BNOT: |
2125 | case LNOT: |
2126 | case LITERAL_true: |
2127 | case LITERAL_false: |
2128 | case LITERAL_null: |
2129 | case LITERAL_new: |
2130 | case NUM_INT: |
2131 | case CHAR_LITERAL: |
2132 | case STRING_LITERAL: |
2133 | case NUM_FLOAT: |
2134 | case NUM_LONG: |
2135 | case NUM_DOUBLE: |
2136 | { |
2137 | annotationMemberArrayValueInitializer(); |
2138 | astFactory.addASTChild(currentAST, returnAST); |
2139 | { |
2140 | _loop72: |
2141 | do { |
2142 | if ((LA(1)==COMMA) && (_tokenSet_10.member(LA(2)))) { |
2143 | match(COMMA); |
2144 | annotationMemberArrayValueInitializer(); |
2145 | astFactory.addASTChild(currentAST, returnAST); |
2146 | } |
2147 | else { |
2148 | break _loop72; |
2149 | } |
2150 | |
2151 | } while (true); |
2152 | } |
2153 | { |
2154 | switch ( LA(1)) { |
2155 | case COMMA: |
2156 | { |
2157 | match(COMMA); |
2158 | break; |
2159 | } |
2160 | case RCURLY: |
2161 | { |
2162 | break; |
2163 | } |
2164 | default: |
2165 | { |
2166 | throw new NoViableAltException(LT(1), getFilename()); |
2167 | } |
2168 | } |
2169 | } |
2170 | break; |
2171 | } |
2172 | case RCURLY: |
2173 | { |
2174 | break; |
2175 | } |
2176 | default: |
2177 | { |
2178 | throw new NoViableAltException(LT(1), getFilename()); |
2179 | } |
2180 | } |
2181 | } |
2182 | match(RCURLY); |
2183 | annotationMemberArrayInitializer_AST = (AST)currentAST.root; |
2184 | returnAST = annotationMemberArrayInitializer_AST; |
2185 | } |
2186 | |
2187 | public final void annotationMemberArrayValueInitializer() throws RecognitionException, TokenStreamException { |
2188 | |
2189 | returnAST = null; |
2190 | ASTPair currentAST = new ASTPair(); |
2191 | AST annotationMemberArrayValueInitializer_AST = null; |
2192 | |
2193 | switch ( LA(1)) { |
2194 | case IDENT: |
2195 | case LITERAL_super: |
2196 | case LT: |
2197 | case LITERAL_void: |
2198 | case LITERAL_boolean: |
2199 | case LITERAL_byte: |
2200 | case LITERAL_char: |
2201 | case LITERAL_short: |
2202 | case LITERAL_int: |
2203 | case LITERAL_float: |
2204 | case LITERAL_long: |
2205 | case LITERAL_double: |
2206 | case LPAREN: |
2207 | case LITERAL_this: |
2208 | case PLUS: |
2209 | case MINUS: |
2210 | case INC: |
2211 | case DEC: |
2212 | case BNOT: |
2213 | case LNOT: |
2214 | case LITERAL_true: |
2215 | case LITERAL_false: |
2216 | case LITERAL_null: |
2217 | case LITERAL_new: |
2218 | case NUM_INT: |
2219 | case CHAR_LITERAL: |
2220 | case STRING_LITERAL: |
2221 | case NUM_FLOAT: |
2222 | case NUM_LONG: |
2223 | case NUM_DOUBLE: |
2224 | { |
2225 | conditionalExpression(); |
2226 | astFactory.addASTChild(currentAST, returnAST); |
2227 | annotationMemberArrayValueInitializer_AST = (AST)currentAST.root; |
2228 | break; |
2229 | } |
2230 | case AT: |
2231 | { |
2232 | annotation(); |
2233 | astFactory.addASTChild(currentAST, returnAST); |
2234 | annotationMemberArrayValueInitializer_AST = (AST)currentAST.root; |
2235 | break; |
2236 | } |
2237 | default: |
2238 | { |
2239 | throw new NoViableAltException(LT(1), getFilename()); |
2240 | } |
2241 | } |
2242 | returnAST = annotationMemberArrayValueInitializer_AST; |
2243 | } |
2244 | |
2245 | public final void superClassClause() throws RecognitionException, TokenStreamException { |
2246 | |
2247 | returnAST = null; |
2248 | ASTPair currentAST = new ASTPair(); |
2249 | AST superClassClause_AST = null; |
2250 | AST c_AST = null; |
2251 | |
2252 | { |
2253 | switch ( LA(1)) { |
2254 | case LITERAL_extends: |
2255 | { |
2256 | match(LITERAL_extends); |
2257 | classOrInterfaceType(false); |
2258 | c_AST = (AST)returnAST; |
2259 | break; |
2260 | } |
2261 | case LCURLY: |
2262 | case LITERAL_implements: |
2263 | { |
2264 | break; |
2265 | } |
2266 | default: |
2267 | { |
2268 | throw new NoViableAltException(LT(1), getFilename()); |
2269 | } |
2270 | } |
2271 | } |
2272 | if ( inputState.guessing==0 ) { |
2273 | superClassClause_AST = (AST)currentAST.root; |
2274 | superClassClause_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(EXTENDS_CLAUSE,"EXTENDS_CLAUSE")).add(c_AST)); |
2275 | currentAST.root = superClassClause_AST; |
2276 | currentAST.child = superClassClause_AST!=null &&superClassClause_AST.getFirstChild()!=null ? |
2277 | superClassClause_AST.getFirstChild() : superClassClause_AST; |
2278 | currentAST.advanceChildToEnd(); |
2279 | } |
2280 | returnAST = superClassClause_AST; |
2281 | } |
2282 | |
2283 | public final void typeParameters() throws RecognitionException, TokenStreamException { |
2284 | |
2285 | returnAST = null; |
2286 | ASTPair currentAST = new ASTPair(); |
2287 | AST typeParameters_AST = null; |
2288 | int currentLtLevel = 0; |
2289 | |
2290 | if ( inputState.guessing==0 ) { |
2291 | currentLtLevel = ltCounter; |
2292 | } |
2293 | match(LT); |
2294 | if ( inputState.guessing==0 ) { |
2295 | ltCounter++; |
2296 | } |
2297 | typeParameter(); |
2298 | astFactory.addASTChild(currentAST, returnAST); |
2299 | { |
2300 | _loop85: |
2301 | do { |
2302 | if ((LA(1)==COMMA)) { |
2303 | match(COMMA); |
2304 | typeParameter(); |
2305 | astFactory.addASTChild(currentAST, returnAST); |
2306 | } |
2307 | else { |
2308 | break _loop85; |
2309 | } |
2310 | |
2311 | } while (true); |
2312 | } |
2313 | { |
2314 | switch ( LA(1)) { |
2315 | case GT: |
2316 | case SR: |
2317 | case BSR: |
2318 | { |
2319 | typeArgumentsOrParametersEnd(); |
2320 | astFactory.addASTChild(currentAST, returnAST); |
2321 | break; |
2322 | } |
2323 | case IDENT: |
2324 | case LITERAL_extends: |
2325 | case LITERAL_void: |
2326 | case LITERAL_boolean: |
2327 | case LITERAL_byte: |
2328 | case LITERAL_char: |
2329 | case LITERAL_short: |
2330 | case LITERAL_int: |
2331 | case LITERAL_float: |
2332 | case LITERAL_long: |
2333 | case LITERAL_double: |
2334 | case LCURLY: |
2335 | case LITERAL_implements: |
2336 | { |
2337 | break; |
2338 | } |
2339 | default: |
2340 | { |
2341 | throw new NoViableAltException(LT(1), getFilename()); |
2342 | } |
2343 | } |
2344 | } |
2345 | if (!((currentLtLevel != 0) || ltCounter == currentLtLevel)) |
2346 | throw new SemanticException("(currentLtLevel != 0) || ltCounter == currentLtLevel"); |
2347 | if ( inputState.guessing==0 ) { |
2348 | typeParameters_AST = (AST)currentAST.root; |
2349 | typeParameters_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(TYPE_PARAMETERS,"TYPE_PARAMETERS")).add(typeParameters_AST)); |
2350 | currentAST.root = typeParameters_AST; |
2351 | currentAST.child = typeParameters_AST!=null &&typeParameters_AST.getFirstChild()!=null ? |
2352 | typeParameters_AST.getFirstChild() : typeParameters_AST; |
2353 | currentAST.advanceChildToEnd(); |
2354 | } |
2355 | typeParameters_AST = (AST)currentAST.root; |
2356 | returnAST = typeParameters_AST; |
2357 | } |
2358 | |
2359 | public final void implementsClause() throws RecognitionException, TokenStreamException { |
2360 | |
2361 | returnAST = null; |
2362 | ASTPair currentAST = new ASTPair(); |
2363 | AST implementsClause_AST = null; |
2364 | Token i = null; |
2365 | AST i_AST = null; |
2366 | |
2367 | { |
2368 | switch ( LA(1)) { |
2369 | case LITERAL_implements: |
2370 | { |
2371 | i = LT(1); |
2372 | i_AST = astFactory.create(i); |
2373 | match(LITERAL_implements); |
2374 | classOrInterfaceType(false); |
2375 | astFactory.addASTChild(currentAST, returnAST); |
2376 | { |
2377 | _loop133: |
2378 | do { |
2379 | if ((LA(1)==COMMA)) { |
2380 | match(COMMA); |
2381 | classOrInterfaceType(false); |
2382 | astFactory.addASTChild(currentAST, returnAST); |
2383 | } |
2384 | else { |
2385 | break _loop133; |
2386 | } |
2387 | |
2388 | } while (true); |
2389 | } |
2390 | break; |
2391 | } |
2392 | case LCURLY: |
2393 | { |
2394 | break; |
2395 | } |
2396 | default: |
2397 | { |
2398 | throw new NoViableAltException(LT(1), getFilename()); |
2399 | } |
2400 | } |
2401 | } |
2402 | if ( inputState.guessing==0 ) { |
2403 | implementsClause_AST = (AST)currentAST.root; |
2404 | implementsClause_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(IMPLEMENTS_CLAUSE,"IMPLEMENTS_CLAUSE")).add(implementsClause_AST)); |
2405 | currentAST.root = implementsClause_AST; |
2406 | currentAST.child = implementsClause_AST!=null &&implementsClause_AST.getFirstChild()!=null ? |
2407 | implementsClause_AST.getFirstChild() : implementsClause_AST; |
2408 | currentAST.advanceChildToEnd(); |
2409 | } |
2410 | implementsClause_AST = (AST)currentAST.root; |
2411 | returnAST = implementsClause_AST; |
2412 | } |
2413 | |
2414 | public final void classBlock() throws RecognitionException, TokenStreamException { |
2415 | |
2416 | returnAST = null; |
2417 | ASTPair currentAST = new ASTPair(); |
2418 | AST classBlock_AST = null; |
2419 | |
2420 | match(LCURLY); |
2421 | { |
2422 | _loop95: |
2423 | do { |
2424 | switch ( LA(1)) { |
2425 | case FINAL: |
2426 | case ABSTRACT: |
2427 | case STRICTFP: |
2428 | case LITERAL_static: |
2429 | case IDENT: |
2430 | case LT: |
2431 | case LITERAL_void: |
2432 | case LITERAL_boolean: |
2433 | case LITERAL_byte: |
2434 | case LITERAL_char: |
2435 | case LITERAL_short: |
2436 | case LITERAL_int: |
2437 | case LITERAL_float: |
2438 | case LITERAL_long: |
2439 | case LITERAL_double: |
2440 | case LITERAL_private: |
2441 | case LITERAL_public: |
2442 | case LITERAL_protected: |
2443 | case LITERAL_transient: |
2444 | case LITERAL_native: |
2445 | case LITERAL_threadsafe: |
2446 | case LITERAL_synchronized: |
2447 | case LITERAL_volatile: |
2448 | case AT: |
2449 | case LCURLY: |
2450 | case LITERAL_class: |
2451 | case LITERAL_interface: |
2452 | case LITERAL_enum: |
2453 | { |
2454 | classField(); |
2455 | astFactory.addASTChild(currentAST, returnAST); |
2456 | break; |
2457 | } |
2458 | case SEMI: |
2459 | { |
2460 | match(SEMI); |
2461 | break; |
2462 | } |
2463 | default: |
2464 | { |
2465 | break _loop95; |
2466 | } |
2467 | } |
2468 | } while (true); |
2469 | } |
2470 | match(RCURLY); |
2471 | if ( inputState.guessing==0 ) { |
2472 | classBlock_AST = (AST)currentAST.root; |
2473 | classBlock_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(OBJBLOCK,"OBJBLOCK")).add(classBlock_AST)); |
2474 | currentAST.root = classBlock_AST; |
2475 | currentAST.child = classBlock_AST!=null &&classBlock_AST.getFirstChild()!=null ? |
2476 | classBlock_AST.getFirstChild() : classBlock_AST; |
2477 | currentAST.advanceChildToEnd(); |
2478 | } |
2479 | classBlock_AST = (AST)currentAST.root; |
2480 | returnAST = classBlock_AST; |
2481 | } |
2482 | |
2483 | public final void interfaceExtends() throws RecognitionException, TokenStreamException { |
2484 | |
2485 | returnAST = null; |
2486 | ASTPair currentAST = new ASTPair(); |
2487 | AST interfaceExtends_AST = null; |
2488 | Token e = null; |
2489 | AST e_AST = null; |
2490 | |
2491 | { |
2492 | switch ( LA(1)) { |
2493 | case LITERAL_extends: |
2494 | { |
2495 | e = LT(1); |
2496 | e_AST = astFactory.create(e); |
2497 | match(LITERAL_extends); |
2498 | classOrInterfaceType(false); |
2499 | astFactory.addASTChild(currentAST, returnAST); |
2500 | { |
2501 | _loop129: |
2502 | do { |
2503 | if ((LA(1)==COMMA)) { |
2504 | match(COMMA); |
2505 | classOrInterfaceType(false); |
2506 | astFactory.addASTChild(currentAST, returnAST); |
2507 | } |
2508 | else { |
2509 | break _loop129; |
2510 | } |
2511 | |
2512 | } while (true); |
2513 | } |
2514 | break; |
2515 | } |
2516 | case LCURLY: |
2517 | { |
2518 | break; |
2519 | } |
2520 | default: |
2521 | { |
2522 | throw new NoViableAltException(LT(1), getFilename()); |
2523 | } |
2524 | } |
2525 | } |
2526 | if ( inputState.guessing==0 ) { |
2527 | interfaceExtends_AST = (AST)currentAST.root; |
2528 | interfaceExtends_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(EXTENDS_CLAUSE,"EXTENDS_CLAUSE")).add(interfaceExtends_AST)); |
2529 | currentAST.root = interfaceExtends_AST; |
2530 | currentAST.child = interfaceExtends_AST!=null &&interfaceExtends_AST.getFirstChild()!=null ? |
2531 | interfaceExtends_AST.getFirstChild() : interfaceExtends_AST; |
2532 | currentAST.advanceChildToEnd(); |
2533 | } |
2534 | interfaceExtends_AST = (AST)currentAST.root; |
2535 | returnAST = interfaceExtends_AST; |
2536 | } |
2537 | |
2538 | public final void interfaceBlock() throws RecognitionException, TokenStreamException { |
2539 | |
2540 | returnAST = null; |
2541 | ASTPair currentAST = new ASTPair(); |
2542 | AST interfaceBlock_AST = null; |
2543 | |
2544 | match(LCURLY); |
2545 | { |
2546 | _loop98: |
2547 | do { |
2548 | switch ( LA(1)) { |
2549 | case FINAL: |
2550 | case ABSTRACT: |
2551 | case STRICTFP: |
2552 | case LITERAL_static: |
2553 | case IDENT: |
2554 | case LT: |
2555 | case LITERAL_void: |
2556 | case LITERAL_boolean: |
2557 | case LITERAL_byte: |
2558 | case LITERAL_char: |
2559 | case LITERAL_short: |
2560 | case LITERAL_int: |
2561 | case LITERAL_float: |
2562 | case LITERAL_long: |
2563 | case LITERAL_double: |
2564 | case LITERAL_private: |
2565 | case LITERAL_public: |
2566 | case LITERAL_protected: |
2567 | case LITERAL_transient: |
2568 | case LITERAL_native: |
2569 | case LITERAL_threadsafe: |
2570 | case LITERAL_synchronized: |
2571 | case LITERAL_volatile: |
2572 | case AT: |
2573 | case LITERAL_class: |
2574 | case LITERAL_interface: |
2575 | case LITERAL_enum: |
2576 | { |
2577 | interfaceField(); |
2578 | astFactory.addASTChild(currentAST, returnAST); |
2579 | break; |
2580 | } |
2581 | case SEMI: |
2582 | { |
2583 | match(SEMI); |
2584 | break; |
2585 | } |
2586 | default: |
2587 | { |
2588 | break _loop98; |
2589 | } |
2590 | } |
2591 | } while (true); |
2592 | } |
2593 | match(RCURLY); |
2594 | if ( inputState.guessing==0 ) { |
2595 | interfaceBlock_AST = (AST)currentAST.root; |
2596 | interfaceBlock_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(OBJBLOCK,"OBJBLOCK")).add(interfaceBlock_AST)); |
2597 | currentAST.root = interfaceBlock_AST; |
2598 | currentAST.child = interfaceBlock_AST!=null &&interfaceBlock_AST.getFirstChild()!=null ? |
2599 | interfaceBlock_AST.getFirstChild() : interfaceBlock_AST; |
2600 | currentAST.advanceChildToEnd(); |
2601 | } |
2602 | interfaceBlock_AST = (AST)currentAST.root; |
2603 | returnAST = interfaceBlock_AST; |
2604 | } |
2605 | |
2606 | public final void enumBlock() throws RecognitionException, TokenStreamException { |
2607 | |
2608 | returnAST = null; |
2609 | ASTPair currentAST = new ASTPair(); |
2610 | AST enumBlock_AST = null; |
2611 | |
2612 | match(LCURLY); |
2613 | { |
2614 | switch ( LA(1)) { |
2615 | case IDENT: |
2616 | case AT: |
2617 | { |
2618 | enumConstant(); |
2619 | astFactory.addASTChild(currentAST, returnAST); |
2620 | { |
2621 | _loop105: |
2622 | do { |
2623 | if ((LA(1)==COMMA) && (LA(2)==IDENT||LA(2)==AT)) { |
2624 | match(COMMA); |
2625 | enumConstant(); |
2626 | astFactory.addASTChild(currentAST, returnAST); |
2627 | } |
2628 | else { |
2629 | break _loop105; |
2630 | } |
2631 | |
2632 | } while (true); |
2633 | } |
2634 | { |
2635 | switch ( LA(1)) { |
2636 | case COMMA: |
2637 | { |
2638 | match(COMMA); |
2639 | break; |
2640 | } |
2641 | case SEMI: |
2642 | case RCURLY: |
2643 | { |
2644 | break; |
2645 | } |
2646 | default: |
2647 | { |
2648 | throw new NoViableAltException(LT(1), getFilename()); |
2649 | } |
2650 | } |
2651 | } |
2652 | break; |
2653 | } |
2654 | case SEMI: |
2655 | case RCURLY: |
2656 | { |
2657 | break; |
2658 | } |
2659 | default: |
2660 | { |
2661 | throw new NoViableAltException(LT(1), getFilename()); |
2662 | } |
2663 | } |
2664 | } |
2665 | { |
2666 | switch ( LA(1)) { |
2667 | case SEMI: |
2668 | { |
2669 | match(SEMI); |
2670 | { |
2671 | _loop109: |
2672 | do { |
2673 | switch ( LA(1)) { |
2674 | case FINAL: |
2675 | case ABSTRACT: |
2676 | case STRICTFP: |
2677 | case LITERAL_static: |
2678 | case IDENT: |
2679 | case LT: |
2680 | case LITERAL_void: |
2681 | case LITERAL_boolean: |
2682 | case LITERAL_byte: |
2683 | case LITERAL_char: |
2684 | case LITERAL_short: |
2685 | case LITERAL_int: |
2686 | case LITERAL_float: |
2687 | case LITERAL_long: |
2688 | case LITERAL_double: |
2689 | case LITERAL_private: |
2690 | case LITERAL_public: |
2691 | case LITERAL_protected: |
2692 | case LITERAL_transient: |
2693 | case LITERAL_native: |
2694 | case LITERAL_threadsafe: |
2695 | case LITERAL_synchronized: |
2696 | case LITERAL_volatile: |
2697 | case AT: |
2698 | case LCURLY: |
2699 | case LITERAL_class: |
2700 | case LITERAL_interface: |
2701 | case LITERAL_enum: |
2702 | { |
2703 | classField(); |
2704 | astFactory.addASTChild(currentAST, returnAST); |
2705 | break; |
2706 | } |
2707 | case SEMI: |
2708 | { |
2709 | match(SEMI); |
2710 | break; |
2711 | } |
2712 | default: |
2713 | { |
2714 | break _loop109; |
2715 | } |
2716 | } |
2717 | } while (true); |
2718 | } |
2719 | break; |
2720 | } |
2721 | case RCURLY: |
2722 | { |
2723 | break; |
2724 | } |
2725 | default: |
2726 | { |
2727 | throw new NoViableAltException(LT(1), getFilename()); |
2728 | } |
2729 | } |
2730 | } |
2731 | match(RCURLY); |
2732 | if ( inputState.guessing==0 ) { |
2733 | enumBlock_AST = (AST)currentAST.root; |
2734 | enumBlock_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(OBJBLOCK,"OBJBLOCK")).add(enumBlock_AST)); |
2735 | currentAST.root = enumBlock_AST; |
2736 | currentAST.child = enumBlock_AST!=null &&enumBlock_AST.getFirstChild()!=null ? |
2737 | enumBlock_AST.getFirstChild() : enumBlock_AST; |
2738 | currentAST.advanceChildToEnd(); |
2739 | } |
2740 | enumBlock_AST = (AST)currentAST.root; |
2741 | returnAST = enumBlock_AST; |
2742 | } |
2743 | |
2744 | public final void annotationBlock() throws RecognitionException, TokenStreamException { |
2745 | |
2746 | returnAST = null; |
2747 | ASTPair currentAST = new ASTPair(); |
2748 | AST annotationBlock_AST = null; |
2749 | |
2750 | match(LCURLY); |
2751 | { |
2752 | _loop101: |
2753 | do { |
2754 | switch ( LA(1)) { |
2755 | case FINAL: |
2756 | case ABSTRACT: |
2757 | case STRICTFP: |
2758 | case LITERAL_static: |
2759 | case IDENT: |
2760 | case LITERAL_void: |
2761 | case LITERAL_boolean: |
2762 | case LITERAL_byte: |
2763 | case LITERAL_char: |
2764 | case LITERAL_short: |
2765 | case LITERAL_int: |
2766 | case LITERAL_float: |
2767 | case LITERAL_long: |
2768 | case LITERAL_double: |
2769 | case LITERAL_private: |
2770 | case LITERAL_public: |
2771 | case LITERAL_protected: |
2772 | case LITERAL_transient: |
2773 | case LITERAL_native: |
2774 | case LITERAL_threadsafe: |
2775 | case LITERAL_synchronized: |
2776 | case LITERAL_volatile: |
2777 | case AT: |
2778 | case LITERAL_class: |
2779 | case LITERAL_interface: |
2780 | case LITERAL_enum: |
2781 | { |
2782 | annotationField(); |
2783 | astFactory.addASTChild(currentAST, returnAST); |
2784 | break; |
2785 | } |
2786 | case SEMI: |
2787 | { |
2788 | match(SEMI); |
2789 | break; |
2790 | } |
2791 | default: |
2792 | { |
2793 | break _loop101; |
2794 | } |
2795 | } |
2796 | } while (true); |
2797 | } |
2798 | match(RCURLY); |
2799 | if ( inputState.guessing==0 ) { |
2800 | annotationBlock_AST = (AST)currentAST.root; |
2801 | annotationBlock_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(OBJBLOCK,"OBJBLOCK")).add(annotationBlock_AST)); |
2802 | currentAST.root = annotationBlock_AST; |
2803 | currentAST.child = annotationBlock_AST!=null &&annotationBlock_AST.getFirstChild()!=null ? |
2804 | annotationBlock_AST.getFirstChild() : annotationBlock_AST; |
2805 | currentAST.advanceChildToEnd(); |
2806 | } |
2807 | annotationBlock_AST = (AST)currentAST.root; |
2808 | returnAST = annotationBlock_AST; |
2809 | } |
2810 | |
2811 | public final void typeParameter() throws RecognitionException, TokenStreamException { |
2812 | |
2813 | returnAST = null; |
2814 | ASTPair currentAST = new ASTPair(); |
2815 | AST typeParameter_AST = null; |
2816 | Token id = null; |
2817 | AST id_AST = null; |
2818 | |
2819 | { |
2820 | id = LT(1); |
2821 | id_AST = astFactory.create(id); |
2822 | astFactory.addASTChild(currentAST, id_AST); |
2823 | match(IDENT); |
2824 | } |
2825 | { |
2826 | if ((LA(1)==LITERAL_extends) && (LA(2)==IDENT)) { |
2827 | typeParameterBounds(); |
2828 | astFactory.addASTChild(currentAST, returnAST); |
2829 | } |
2830 | else if ((_tokenSet_11.member(LA(1))) && (_tokenSet_12.member(LA(2)))) { |
2831 | } |
2832 | else { |
2833 | throw new NoViableAltException(LT(1), getFilename()); |
2834 | } |
2835 | |
2836 | } |
2837 | if ( inputState.guessing==0 ) { |
2838 | typeParameter_AST = (AST)currentAST.root; |
2839 | typeParameter_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(TYPE_PARAMETER,"TYPE_PARAMETER")).add(typeParameter_AST)); |
2840 | currentAST.root = typeParameter_AST; |
2841 | currentAST.child = typeParameter_AST!=null &&typeParameter_AST.getFirstChild()!=null ? |
2842 | typeParameter_AST.getFirstChild() : typeParameter_AST; |
2843 | currentAST.advanceChildToEnd(); |
2844 | } |
2845 | typeParameter_AST = (AST)currentAST.root; |
2846 | returnAST = typeParameter_AST; |
2847 | } |
2848 | |
2849 | public final void typeParameterBounds() throws RecognitionException, TokenStreamException { |
2850 | |
2851 | returnAST = null; |
2852 | ASTPair currentAST = new ASTPair(); |
2853 | AST typeParameterBounds_AST = null; |
2854 | |
2855 | match(LITERAL_extends); |
2856 | classOrInterfaceType(false); |
2857 | astFactory.addASTChild(currentAST, returnAST); |
2858 | { |
2859 | _loop92: |
2860 | do { |
2861 | if ((LA(1)==BAND)) { |
2862 | match(BAND); |
2863 | classOrInterfaceType(false); |
2864 | astFactory.addASTChild(currentAST, returnAST); |
2865 | } |
2866 | else { |
2867 | break _loop92; |
2868 | } |
2869 | |
2870 | } while (true); |
2871 | } |
2872 | if ( inputState.guessing==0 ) { |
2873 | typeParameterBounds_AST = (AST)currentAST.root; |
2874 | typeParameterBounds_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(TYPE_UPPER_BOUNDS,"TYPE_UPPER_BOUNDS")).add(typeParameterBounds_AST)); |
2875 | currentAST.root = typeParameterBounds_AST; |
2876 | currentAST.child = typeParameterBounds_AST!=null &&typeParameterBounds_AST.getFirstChild()!=null ? |
2877 | typeParameterBounds_AST.getFirstChild() : typeParameterBounds_AST; |
2878 | currentAST.advanceChildToEnd(); |
2879 | } |
2880 | typeParameterBounds_AST = (AST)currentAST.root; |
2881 | returnAST = typeParameterBounds_AST; |
2882 | } |
2883 | |
2884 | public final void classField() throws RecognitionException, TokenStreamException { |
2885 | |
2886 | returnAST = null; |
2887 | ASTPair currentAST = new ASTPair(); |
2888 | AST classField_AST = null; |
2889 | AST mods_AST = null; |
2890 | AST td_AST = null; |
2891 | AST tp_AST = null; |
2892 | AST h_AST = null; |
2893 | AST s_AST = null; |
2894 | AST t_AST = null; |
2895 | AST param_AST = null; |
2896 | AST rt_AST = null; |
2897 | AST tc_AST = null; |
2898 | AST s2_AST = null; |
2899 | AST v_AST = null; |
2900 | AST s3_AST = null; |
2901 | AST s4_AST = null; |
2902 | |
2903 | if ((_tokenSet_13.member(LA(1))) && (_tokenSet_14.member(LA(2)))) { |
2904 | modifiers(); |
2905 | mods_AST = (AST)returnAST; |
2906 | { |
2907 | switch ( LA(1)) { |
2908 | case AT: |
2909 | case LITERAL_class: |
2910 | case LITERAL_interface: |
2911 | case LITERAL_enum: |
2912 | { |
2913 | typeDefinitionInternal(mods_AST); |
2914 | td_AST = (AST)returnAST; |
2915 | if ( inputState.guessing==0 ) { |
2916 | classField_AST = (AST)currentAST.root; |
2917 | classField_AST = td_AST; |
2918 | currentAST.root = classField_AST; |
2919 | currentAST.child = classField_AST!=null &&classField_AST.getFirstChild()!=null ? |
2920 | classField_AST.getFirstChild() : classField_AST; |
2921 | currentAST.advanceChildToEnd(); |
2922 | } |
2923 | break; |
2924 | } |
2925 | case IDENT: |
2926 | case LT: |
2927 | case LITERAL_void: |
2928 | case LITERAL_boolean: |
2929 | case LITERAL_byte: |
2930 | case LITERAL_char: |
2931 | case LITERAL_short: |
2932 | case LITERAL_int: |
2933 | case LITERAL_float: |
2934 | case LITERAL_long: |
2935 | case LITERAL_double: |
2936 | { |
2937 | { |
2938 | switch ( LA(1)) { |
2939 | case LT: |
2940 | { |
2941 | typeParameters(); |
2942 | tp_AST = (AST)returnAST; |
2943 | break; |
2944 | } |
2945 | case IDENT: |
2946 | case LITERAL_void: |
2947 | case LITERAL_boolean: |
2948 | case LITERAL_byte: |
2949 | case LITERAL_char: |
2950 | case LITERAL_short: |
2951 | case LITERAL_int: |
2952 | case LITERAL_float: |
2953 | case LITERAL_long: |
2954 | case LITERAL_double: |
2955 | { |
2956 | break; |
2957 | } |
2958 | default: |
2959 | { |
2960 | throw new NoViableAltException(LT(1), getFilename()); |
2961 | } |
2962 | } |
2963 | } |
2964 | { |
2965 | if ((LA(1)==IDENT) && (LA(2)==LPAREN)) { |
2966 | ctorHead(); |
2967 | h_AST = (AST)returnAST; |
2968 | constructorBody(); |
2969 | s_AST = (AST)returnAST; |
2970 | if ( inputState.guessing==0 ) { |
2971 | classField_AST = (AST)currentAST.root; |
2972 | classField_AST = (AST)astFactory.make( (new ASTArray(5)).add(astFactory.create(CTOR_DEF,"CTOR_DEF")).add(mods_AST).add(tp_AST).add(h_AST).add(s_AST)); |
2973 | currentAST.root = classField_AST; |
2974 | currentAST.child = classField_AST!=null &&classField_AST.getFirstChild()!=null ? |
2975 | classField_AST.getFirstChild() : classField_AST; |
2976 | currentAST.advanceChildToEnd(); |
2977 | } |
2978 | } |
2979 | else if ((_tokenSet_15.member(LA(1))) && (_tokenSet_16.member(LA(2)))) { |
2980 | typeSpec(false); |
2981 | t_AST = (AST)returnAST; |
2982 | { |
2983 | if ((LA(1)==IDENT) && (LA(2)==LPAREN)) { |
2984 | AST tmp90_AST = null; |
2985 | tmp90_AST = astFactory.create(LT(1)); |
2986 | match(IDENT); |
2987 | match(LPAREN); |
2988 | parameterDeclarationList(); |
2989 | param_AST = (AST)returnAST; |
2990 | match(RPAREN); |
2991 | declaratorBrackets(t_AST); |
2992 | rt_AST = (AST)returnAST; |
2993 | { |
2994 | switch ( LA(1)) { |
2995 | case LITERAL_throws: |
2996 | { |
2997 | throwsClause(); |
2998 | tc_AST = (AST)returnAST; |
2999 | break; |
3000 | } |
3001 | case SEMI: |
3002 | case LCURLY: |
3003 | { |
3004 | break; |
3005 | } |
3006 | default: |
3007 | { |
3008 | throw new NoViableAltException(LT(1), getFilename()); |
3009 | } |
3010 | } |
3011 | } |
3012 | { |
3013 | switch ( LA(1)) { |
3014 | case LCURLY: |
3015 | { |
3016 | compoundStatement(); |
3017 | s2_AST = (AST)returnAST; |
3018 | break; |
3019 | } |
3020 | case SEMI: |
3021 | { |
3022 | AST tmp93_AST = null; |
3023 | tmp93_AST = astFactory.create(LT(1)); |
3024 | match(SEMI); |
3025 | break; |
3026 | } |
3027 | default: |
3028 | { |
3029 | throw new NoViableAltException(LT(1), getFilename()); |
3030 | } |
3031 | } |
3032 | } |
3033 | if ( inputState.guessing==0 ) { |
3034 | classField_AST = (AST)currentAST.root; |
3035 | classField_AST = (AST)astFactory.make( (new ASTArray(8)).add(astFactory.create(METHOD_DEF,"METHOD_DEF")).add(mods_AST).add(tp_AST).add((AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(TYPE,"TYPE")).add(rt_AST))).add(tmp90_AST).add(param_AST).add(tc_AST).add(s2_AST)); |
3036 | currentAST.root = classField_AST; |
3037 | currentAST.child = classField_AST!=null &&classField_AST.getFirstChild()!=null ? |
3038 | classField_AST.getFirstChild() : classField_AST; |
3039 | currentAST.advanceChildToEnd(); |
3040 | } |
3041 | } |
3042 | else if ((LA(1)==IDENT) && (_tokenSet_17.member(LA(2)))) { |
3043 | variableDefinitions(mods_AST,t_AST); |
3044 | v_AST = (AST)returnAST; |
3045 | AST tmp94_AST = null; |
3046 | tmp94_AST = astFactory.create(LT(1)); |
3047 | match(SEMI); |
3048 | if ( inputState.guessing==0 ) { |
3049 | classField_AST = (AST)currentAST.root; |
3050 | classField_AST = v_AST; |
3051 | currentAST.root = classField_AST; |
3052 | currentAST.child = classField_AST!=null &&classField_AST.getFirstChild()!=null ? |
3053 | classField_AST.getFirstChild() : classField_AST; |
3054 | currentAST.advanceChildToEnd(); |
3055 | } |
3056 | } |
3057 | else { |
3058 | throw new NoViableAltException(LT(1), getFilename()); |
3059 | } |
3060 | |
3061 | } |
3062 | } |
3063 | else { |
3064 | throw new NoViableAltException(LT(1), getFilename()); |
3065 | } |
3066 | |
3067 | } |
3068 | break; |
3069 | } |
3070 | default: |
3071 | { |
3072 | throw new NoViableAltException(LT(1), getFilename()); |
3073 | } |
3074 | } |
3075 | } |
3076 | } |
3077 | else if ((LA(1)==LITERAL_static) && (LA(2)==LCURLY)) { |
3078 | match(LITERAL_static); |
3079 | compoundStatement(); |
3080 | s3_AST = (AST)returnAST; |
3081 | if ( inputState.guessing==0 ) { |
3082 | classField_AST = (AST)currentAST.root; |
3083 | classField_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(STATIC_INIT,"STATIC_INIT")).add(s3_AST)); |
3084 | currentAST.root = classField_AST; |
3085 | currentAST.child = classField_AST!=null &&classField_AST.getFirstChild()!=null ? |
3086 | classField_AST.getFirstChild() : classField_AST; |
3087 | currentAST.advanceChildToEnd(); |
3088 | } |
3089 | } |
3090 | else if ((LA(1)==LCURLY)) { |
3091 | compoundStatement(); |
3092 | s4_AST = (AST)returnAST; |
3093 | if ( inputState.guessing==0 ) { |
3094 | classField_AST = (AST)currentAST.root; |
3095 | classField_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(INSTANCE_INIT,"INSTANCE_INIT")).add(s4_AST)); |
3096 | currentAST.root = classField_AST; |
3097 | currentAST.child = classField_AST!=null &&classField_AST.getFirstChild()!=null ? |
3098 | classField_AST.getFirstChild() : classField_AST; |
3099 | currentAST.advanceChildToEnd(); |
3100 | } |
3101 | } |
3102 | else { |
3103 | throw new NoViableAltException(LT(1), getFilename()); |
3104 | } |
3105 | |
3106 | returnAST = classField_AST; |
3107 | } |
3108 | |
3109 | public final void interfaceField() throws RecognitionException, TokenStreamException { |
3110 | |
3111 | returnAST = null; |
3112 | ASTPair currentAST = new ASTPair(); |
3113 | AST interfaceField_AST = null; |
3114 | AST mods_AST = null; |
3115 | AST td_AST = null; |
3116 | AST tp_AST = null; |
3117 | AST t_AST = null; |
3118 | AST param_AST = null; |
3119 | AST rt_AST = null; |
3120 | AST tc_AST = null; |
3121 | AST v_AST = null; |
3122 | |
3123 | modifiers(); |
3124 | mods_AST = (AST)returnAST; |
3125 | { |
3126 | switch ( LA(1)) { |
3127 | case AT: |
3128 | case LITERAL_class: |
3129 | case LITERAL_interface: |
3130 | case LITERAL_enum: |
3131 | { |
3132 | typeDefinitionInternal(mods_AST); |
3133 | td_AST = (AST)returnAST; |
3134 | if ( inputState.guessing==0 ) { |
3135 | interfaceField_AST = (AST)currentAST.root; |
3136 | interfaceField_AST = td_AST; |
3137 | currentAST.root = interfaceField_AST; |
3138 | currentAST.child = interfaceField_AST!=null &&interfaceField_AST.getFirstChild()!=null ? |
3139 | interfaceField_AST.getFirstChild() : interfaceField_AST; |
3140 | currentAST.advanceChildToEnd(); |
3141 | } |
3142 | break; |
3143 | } |
3144 | case IDENT: |
3145 | case LT: |
3146 | case LITERAL_void: |
3147 | case LITERAL_boolean: |
3148 | case LITERAL_byte: |
3149 | case LITERAL_char: |
3150 | case LITERAL_short: |
3151 | case LITERAL_int: |
3152 | case LITERAL_float: |
3153 | case LITERAL_long: |
3154 | case LITERAL_double: |
3155 | { |
3156 | { |
3157 | switch ( LA(1)) { |
3158 | case LT: |
3159 | { |
3160 | typeParameters(); |
3161 | tp_AST = (AST)returnAST; |
3162 | break; |
3163 | } |
3164 | case IDENT: |
3165 | case LITERAL_void: |
3166 | case LITERAL_boolean: |
3167 | case LITERAL_byte: |
3168 | case LITERAL_char: |
3169 | case LITERAL_short: |
3170 | case LITERAL_int: |
3171 | case LITERAL_float: |
3172 | case LITERAL_long: |
3173 | case LITERAL_double: |
3174 | { |
3175 | break; |
3176 | } |
3177 | default: |
3178 | { |
3179 | throw new NoViableAltException(LT(1), getFilename()); |
3180 | } |
3181 | } |
3182 | } |
3183 | typeSpec(false); |
3184 | t_AST = (AST)returnAST; |
3185 | { |
3186 | if ((LA(1)==IDENT) && (LA(2)==LPAREN)) { |
3187 | AST tmp96_AST = null; |
3188 | tmp96_AST = astFactory.create(LT(1)); |
3189 | match(IDENT); |
3190 | match(LPAREN); |
3191 | parameterDeclarationList(); |
3192 | param_AST = (AST)returnAST; |
3193 | match(RPAREN); |
3194 | declaratorBrackets(t_AST); |
3195 | rt_AST = (AST)returnAST; |
3196 | { |
3197 | switch ( LA(1)) { |
3198 | case LITERAL_throws: |
3199 | { |
3200 | throwsClause(); |
3201 | tc_AST = (AST)returnAST; |
3202 | break; |
3203 | } |
3204 | case SEMI: |
3205 | { |
3206 | break; |
3207 | } |
3208 | default: |
3209 | { |
3210 | throw new NoViableAltException(LT(1), getFilename()); |
3211 | } |
3212 | } |
3213 | } |
3214 | AST tmp99_AST = null; |
3215 | tmp99_AST = astFactory.create(LT(1)); |
3216 | match(SEMI); |
3217 | if ( inputState.guessing==0 ) { |
3218 | interfaceField_AST = (AST)currentAST.root; |
3219 | interfaceField_AST = (AST)astFactory.make( (new ASTArray(7)).add(astFactory.create(METHOD_DEF,"METHOD_DEF")).add(mods_AST).add(tp_AST).add((AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(TYPE,"TYPE")).add(rt_AST))).add(tmp96_AST).add(param_AST).add(tc_AST)); |
3220 | currentAST.root = interfaceField_AST; |
3221 | currentAST.child = interfaceField_AST!=null &&interfaceField_AST.getFirstChild()!=null ? |
3222 | interfaceField_AST.getFirstChild() : interfaceField_AST; |
3223 | currentAST.advanceChildToEnd(); |
3224 | } |
3225 | } |
3226 | else if ((LA(1)==IDENT) && (_tokenSet_17.member(LA(2)))) { |
3227 | variableDefinitions(mods_AST,t_AST); |
3228 | v_AST = (AST)returnAST; |
3229 | AST tmp100_AST = null; |
3230 | tmp100_AST = astFactory.create(LT(1)); |
3231 | match(SEMI); |
3232 | if ( inputState.guessing==0 ) { |
3233 | interfaceField_AST = (AST)currentAST.root; |
3234 | interfaceField_AST = v_AST; |
3235 | currentAST.root = interfaceField_AST; |
3236 | currentAST.child = interfaceField_AST!=null &&interfaceField_AST.getFirstChild()!=null ? |
3237 | interfaceField_AST.getFirstChild() : interfaceField_AST; |
3238 | currentAST.advanceChildToEnd(); |
3239 | } |
3240 | } |
3241 | else { |
3242 | throw new NoViableAltException(LT(1), getFilename()); |
3243 | } |
3244 | |
3245 | } |
3246 | break; |
3247 | } |
3248 | default: |
3249 | { |
3250 | throw new NoViableAltException(LT(1), getFilename()); |
3251 | } |
3252 | } |
3253 | } |
3254 | returnAST = interfaceField_AST; |
3255 | } |
3256 | |
3257 | public final void annotationField() throws RecognitionException, TokenStreamException { |
3258 | |
3259 | returnAST = null; |
3260 | ASTPair currentAST = new ASTPair(); |
3261 | AST annotationField_AST = null; |
3262 | AST mods_AST = null; |
3263 | AST td_AST = null; |
3264 | AST t_AST = null; |
3265 | Token i = null; |
3266 | AST i_AST = null; |
3267 | AST rt_AST = null; |
3268 | AST amvi_AST = null; |
3269 | AST v_AST = null; |
3270 | |
3271 | modifiers(); |
3272 | mods_AST = (AST)returnAST; |
3273 | { |
3274 | switch ( LA(1)) { |
3275 | case AT: |
3276 | case LITERAL_class: |
3277 | case LITERAL_interface: |
3278 | case LITERAL_enum: |
3279 | { |
3280 | typeDefinitionInternal(mods_AST); |
3281 | td_AST = (AST)returnAST; |
3282 | if ( inputState.guessing==0 ) { |
3283 | annotationField_AST = (AST)currentAST.root; |
3284 | annotationField_AST = td_AST; |
3285 | currentAST.root = annotationField_AST; |
3286 | currentAST.child = annotationField_AST!=null &&annotationField_AST.getFirstChild()!=null ? |
3287 | annotationField_AST.getFirstChild() : annotationField_AST; |
3288 | currentAST.advanceChildToEnd(); |
3289 | } |
3290 | break; |
3291 | } |
3292 | case IDENT: |
3293 | case LITERAL_void: |
3294 | case LITERAL_boolean: |
3295 | case LITERAL_byte: |
3296 | case LITERAL_char: |
3297 | case LITERAL_short: |
3298 | case LITERAL_int: |
3299 | case LITERAL_float: |
3300 | case LITERAL_long: |
3301 | case LITERAL_double: |
3302 | { |
3303 | typeSpec(false); |
3304 | t_AST = (AST)returnAST; |
3305 | { |
3306 | if ((LA(1)==IDENT) && (LA(2)==LPAREN)) { |
3307 | i = LT(1); |
3308 | i_AST = astFactory.create(i); |
3309 | match(IDENT); |
3310 | match(LPAREN); |
3311 | match(RPAREN); |
3312 | declaratorBrackets(t_AST); |
3313 | rt_AST = (AST)returnAST; |
3314 | { |
3315 | switch ( LA(1)) { |
3316 | case LITERAL_default: |
3317 | { |
3318 | match(LITERAL_default); |
3319 | annotationMemberValueInitializer(); |
3320 | amvi_AST = (AST)returnAST; |
3321 | break; |
3322 | } |
3323 | case SEMI: |
3324 | { |
3325 | break; |
3326 | } |
3327 | default: |
3328 | { |
3329 | throw new NoViableAltException(LT(1), getFilename()); |
3330 | } |
3331 | } |
3332 | } |
3333 | AST tmp104_AST = null; |
3334 | tmp104_AST = astFactory.create(LT(1)); |
3335 | match(SEMI); |
3336 | if ( inputState.guessing==0 ) { |
3337 | annotationField_AST = (AST)currentAST.root; |
3338 | annotationField_AST = |
3339 | (AST)astFactory.make( (new ASTArray(5)).add(astFactory.create(ANNOTATION_FIELD_DEF,"ANNOTATION_FIELD_DEF")).add(mods_AST).add((AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(TYPE,"TYPE")).add(rt_AST))).add(i_AST).add(amvi_AST)); |
3340 | currentAST.root = annotationField_AST; |
3341 | currentAST.child = annotationField_AST!=null &&annotationField_AST.getFirstChild()!=null ? |
3342 | annotationField_AST.getFirstChild() : annotationField_AST; |
3343 | currentAST.advanceChildToEnd(); |
3344 | } |
3345 | } |
3346 | else if ((LA(1)==IDENT) && (_tokenSet_17.member(LA(2)))) { |
3347 | variableDefinitions(mods_AST,t_AST); |
3348 | v_AST = (AST)returnAST; |
3349 | AST tmp105_AST = null; |
3350 | tmp105_AST = astFactory.create(LT(1)); |
3351 | match(SEMI); |
3352 | if ( inputState.guessing==0 ) { |
3353 | annotationField_AST = (AST)currentAST.root; |
3354 | annotationField_AST = v_AST; |
3355 | currentAST.root = annotationField_AST; |
3356 | currentAST.child = annotationField_AST!=null &&annotationField_AST.getFirstChild()!=null ? |
3357 | annotationField_AST.getFirstChild() : annotationField_AST; |
3358 | currentAST.advanceChildToEnd(); |
3359 | } |
3360 | } |
3361 | else { |
3362 | throw new NoViableAltException(LT(1), getFilename()); |
3363 | } |
3364 | |
3365 | } |
3366 | break; |
3367 | } |
3368 | default: |
3369 | { |
3370 | throw new NoViableAltException(LT(1), getFilename()); |
3371 | } |
3372 | } |
3373 | } |
3374 | returnAST = annotationField_AST; |
3375 | } |
3376 | |
3377 | public final void enumConstant() throws RecognitionException, TokenStreamException { |
3378 | |
3379 | returnAST = null; |
3380 | ASTPair currentAST = new ASTPair(); |
3381 | AST enumConstant_AST = null; |
3382 | AST an_AST = null; |
3383 | Token i = null; |
3384 | AST i_AST = null; |
3385 | AST a_AST = null; |
3386 | AST b_AST = null; |
3387 | |
3388 | annotations(); |
3389 | an_AST = (AST)returnAST; |
3390 | i = LT(1); |
3391 | i_AST = astFactory.create(i); |
3392 | match(IDENT); |
3393 | { |
3394 | switch ( LA(1)) { |
3395 | case LPAREN: |
3396 | { |
3397 | match(LPAREN); |
3398 | argList(); |
3399 | a_AST = (AST)returnAST; |
3400 | match(RPAREN); |
3401 | break; |
3402 | } |
3403 | case SEMI: |
3404 | case COMMA: |
3405 | case LCURLY: |
3406 | case RCURLY: |
3407 | { |
3408 | break; |
3409 | } |
3410 | default: |
3411 | { |
3412 | throw new NoViableAltException(LT(1), getFilename()); |
3413 | } |
3414 | } |
3415 | } |
3416 | { |
3417 | switch ( LA(1)) { |
3418 | case LCURLY: |
3419 | { |
3420 | enumConstantBlock(); |
3421 | b_AST = (AST)returnAST; |
3422 | break; |
3423 | } |
3424 | case SEMI: |
3425 | case COMMA: |
3426 | case RCURLY: |
3427 | { |
3428 | break; |
3429 | } |
3430 | default: |
3431 | { |
3432 | throw new NoViableAltException(LT(1), getFilename()); |
3433 | } |
3434 | } |
3435 | } |
3436 | if ( inputState.guessing==0 ) { |
3437 | enumConstant_AST = (AST)currentAST.root; |
3438 | enumConstant_AST = (AST)astFactory.make( (new ASTArray(5)).add(astFactory.create(ENUM_CONSTANT_DEF,"ENUM_CONSTANT_DEF")).add(an_AST).add(i_AST).add(a_AST).add(b_AST)); |
3439 | currentAST.root = enumConstant_AST; |
3440 | currentAST.child = enumConstant_AST!=null &&enumConstant_AST.getFirstChild()!=null ? |
3441 | enumConstant_AST.getFirstChild() : enumConstant_AST; |
3442 | currentAST.advanceChildToEnd(); |
3443 | } |
3444 | returnAST = enumConstant_AST; |
3445 | } |
3446 | |
3447 | public final void declaratorBrackets( |
3448 | AST typ |
3449 | ) throws RecognitionException, TokenStreamException { |
3450 | |
3451 | returnAST = null; |
3452 | ASTPair currentAST = new ASTPair(); |
3453 | AST declaratorBrackets_AST = null; |
3454 | Token lb = null; |
3455 | AST lb_AST = null; |
3456 | |
3457 | if ( inputState.guessing==0 ) { |
3458 | declaratorBrackets_AST = (AST)currentAST.root; |
3459 | declaratorBrackets_AST=typ; |
3460 | currentAST.root = declaratorBrackets_AST; |
3461 | currentAST.child = declaratorBrackets_AST!=null &&declaratorBrackets_AST.getFirstChild()!=null ? |
3462 | declaratorBrackets_AST.getFirstChild() : declaratorBrackets_AST; |
3463 | currentAST.advanceChildToEnd(); |
3464 | } |
3465 | { |
3466 | _loop159: |
3467 | do { |
3468 | if ((LA(1)==LBRACK)) { |
3469 | lb = LT(1); |
3470 | lb_AST = astFactory.create(lb); |
3471 | astFactory.makeASTRoot(currentAST, lb_AST); |
3472 | match(LBRACK); |
3473 | if ( inputState.guessing==0 ) { |
3474 | lb_AST.setType(ARRAY_DECLARATOR); |
3475 | } |
3476 | match(RBRACK); |
3477 | } |
3478 | else { |
3479 | break _loop159; |
3480 | } |
3481 | |
3482 | } while (true); |
3483 | } |
3484 | declaratorBrackets_AST = (AST)currentAST.root; |
3485 | returnAST = declaratorBrackets_AST; |
3486 | } |
3487 | |
3488 | public final void argList() throws RecognitionException, TokenStreamException { |
3489 | |
3490 | returnAST = null; |
3491 | ASTPair currentAST = new ASTPair(); |
3492 | AST argList_AST = null; |
3493 | |
3494 | { |
3495 | switch ( LA(1)) { |
3496 | case IDENT: |
3497 | case LITERAL_super: |
3498 | case LT: |
3499 | case LITERAL_void: |
3500 | case LITERAL_boolean: |
3501 | case LITERAL_byte: |
3502 | case LITERAL_char: |
3503 | case LITERAL_short: |
3504 | case LITERAL_int: |
3505 | case LITERAL_float: |
3506 | case LITERAL_long: |
3507 | case LITERAL_double: |
3508 | case LPAREN: |
3509 | case LITERAL_this: |
3510 | case PLUS: |
3511 | case MINUS: |
3512 | case INC: |
3513 | case DEC: |
3514 | case BNOT: |
3515 | case LNOT: |
3516 | case LITERAL_true: |
3517 | case LITERAL_false: |
3518 | case LITERAL_null: |
3519 | case LITERAL_new: |
3520 | case NUM_INT: |
3521 | case CHAR_LITERAL: |
3522 | case STRING_LITERAL: |
3523 | case NUM_FLOAT: |
3524 | case NUM_LONG: |
3525 | case NUM_DOUBLE: |
3526 | { |
3527 | expressionList(); |
3528 | astFactory.addASTChild(currentAST, returnAST); |
3529 | break; |
3530 | } |
3531 | case RPAREN: |
3532 | { |
3533 | if ( inputState.guessing==0 ) { |
3534 | argList_AST = (AST)currentAST.root; |
3535 | argList_AST = astFactory.create(ELIST,"ELIST"); |
3536 | currentAST.root = argList_AST; |
3537 | currentAST.child = argList_AST!=null &&argList_AST.getFirstChild()!=null ? |
3538 | argList_AST.getFirstChild() : argList_AST; |
3539 | currentAST.advanceChildToEnd(); |
3540 | } |
3541 | break; |
3542 | } |
3543 | default: |
3544 | { |
3545 | throw new NoViableAltException(LT(1), getFilename()); |
3546 | } |
3547 | } |
3548 | } |
3549 | argList_AST = (AST)currentAST.root; |
3550 | returnAST = argList_AST; |
3551 | } |
3552 | |
3553 | public final void enumConstantBlock() throws RecognitionException, TokenStreamException { |
3554 | |
3555 | returnAST = null; |
3556 | ASTPair currentAST = new ASTPair(); |
3557 | AST enumConstantBlock_AST = null; |
3558 | |
3559 | match(LCURLY); |
3560 | { |
3561 | _loop119: |
3562 | do { |
3563 | switch ( LA(1)) { |
3564 | case FINAL: |
3565 | case ABSTRACT: |
3566 | case STRICTFP: |
3567 | case LITERAL_static: |
3568 | case IDENT: |
3569 | case LT: |
3570 | case LITERAL_void: |
3571 | case LITERAL_boolean: |
3572 | case LITERAL_byte: |
3573 | case LITERAL_char: |
3574 | case LITERAL_short: |
3575 | case LITERAL_int: |
3576 | case LITERAL_float: |
3577 | case LITERAL_long: |
3578 | case LITERAL_double: |
3579 | case LITERAL_private: |
3580 | case LITERAL_public: |
3581 | case LITERAL_protected: |
3582 | case LITERAL_transient: |
3583 | case LITERAL_native: |
3584 | case LITERAL_threadsafe: |
3585 | case LITERAL_synchronized: |
3586 | case LITERAL_volatile: |
3587 | case AT: |
3588 | case LCURLY: |
3589 | case LITERAL_class: |
3590 | case LITERAL_interface: |
3591 | case LITERAL_enum: |
3592 | { |
3593 | enumConstantField(); |
3594 | astFactory.addASTChild(currentAST, returnAST); |
3595 | break; |
3596 | } |
3597 | case SEMI: |
3598 | { |
3599 | match(SEMI); |
3600 | break; |
3601 | } |
3602 | default: |
3603 | { |
3604 | break _loop119; |
3605 | } |
3606 | } |
3607 | } while (true); |
3608 | } |
3609 | match(RCURLY); |
3610 | if ( inputState.guessing==0 ) { |
3611 | enumConstantBlock_AST = (AST)currentAST.root; |
3612 | enumConstantBlock_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(OBJBLOCK,"OBJBLOCK")).add(enumConstantBlock_AST)); |
3613 | currentAST.root = enumConstantBlock_AST; |
3614 | currentAST.child = enumConstantBlock_AST!=null &&enumConstantBlock_AST.getFirstChild()!=null ? |
3615 | enumConstantBlock_AST.getFirstChild() : enumConstantBlock_AST; |
3616 | currentAST.advanceChildToEnd(); |
3617 | } |
3618 | enumConstantBlock_AST = (AST)currentAST.root; |
3619 | returnAST = enumConstantBlock_AST; |
3620 | } |
3621 | |
3622 | public final void enumConstantField() throws RecognitionException, TokenStreamException { |
3623 | |
3624 | returnAST = null; |
3625 | ASTPair currentAST = new ASTPair(); |
3626 | AST enumConstantField_AST = null; |
3627 | AST mods_AST = null; |
3628 | AST td_AST = null; |
3629 | AST tp_AST = null; |
3630 | AST t_AST = null; |
3631 | AST param_AST = null; |
3632 | AST rt_AST = null; |
3633 | AST tc_AST = null; |
3634 | AST s2_AST = null; |
3635 | AST v_AST = null; |
3636 | AST s4_AST = null; |
3637 | |
3638 | switch ( LA(1)) { |
3639 | case FINAL: |
3640 | case ABSTRACT: |
3641 | case STRICTFP: |
3642 | case LITERAL_static: |
3643 | case IDENT: |
3644 | case LT: |
3645 | case LITERAL_void: |
3646 | case LITERAL_boolean: |
3647 | case LITERAL_byte: |
3648 | case LITERAL_char: |
3649 | case LITERAL_short: |
3650 | case LITERAL_int: |
3651 | case LITERAL_float: |
3652 | case LITERAL_long: |
3653 | case LITERAL_double: |
3654 | case LITERAL_private: |
3655 | case LITERAL_public: |
3656 | case LITERAL_protected: |
3657 | case LITERAL_transient: |
3658 | case LITERAL_native: |
3659 | case LITERAL_threadsafe: |
3660 | case LITERAL_synchronized: |
3661 | case LITERAL_volatile: |
3662 | case AT: |
3663 | case LITERAL_class: |
3664 | case LITERAL_interface: |
3665 | case LITERAL_enum: |
3666 | { |
3667 | modifiers(); |
3668 | mods_AST = (AST)returnAST; |
3669 | { |
3670 | switch ( LA(1)) { |
3671 | case AT: |
3672 | case LITERAL_class: |
3673 | case LITERAL_interface: |
3674 | case LITERAL_enum: |
3675 | { |
3676 | typeDefinitionInternal(mods_AST); |
3677 | td_AST = (AST)returnAST; |
3678 | if ( inputState.guessing==0 ) { |
3679 | enumConstantField_AST = (AST)currentAST.root; |
3680 | enumConstantField_AST = td_AST; |
3681 | currentAST.root = enumConstantField_AST; |
3682 | currentAST.child = enumConstantField_AST!=null &&enumConstantField_AST.getFirstChild()!=null ? |
3683 | enumConstantField_AST.getFirstChild() : enumConstantField_AST; |
3684 | currentAST.advanceChildToEnd(); |
3685 | } |
3686 | break; |
3687 | } |
3688 | case IDENT: |
3689 | case LT: |
3690 | case LITERAL_void: |
3691 | case LITERAL_boolean: |
3692 | case LITERAL_byte: |
3693 | case LITERAL_char: |
3694 | case LITERAL_short: |
3695 | case LITERAL_int: |
3696 | case LITERAL_float: |
3697 | case LITERAL_long: |
3698 | case LITERAL_double: |
3699 | { |
3700 | { |
3701 | switch ( LA(1)) { |
3702 | case LT: |
3703 | { |
3704 | typeParameters(); |
3705 | tp_AST = (AST)returnAST; |
3706 | break; |
3707 | } |
3708 | case IDENT: |
3709 | case LITERAL_void: |
3710 | case LITERAL_boolean: |
3711 | case LITERAL_byte: |
3712 | case LITERAL_char: |
3713 | case LITERAL_short: |
3714 | case LITERAL_int: |
3715 | case LITERAL_float: |
3716 | case LITERAL_long: |
3717 | case LITERAL_double: |
3718 | { |
3719 | break; |
3720 | } |
3721 | default: |
3722 | { |
3723 | throw new NoViableAltException(LT(1), getFilename()); |
3724 | } |
3725 | } |
3726 | } |
3727 | typeSpec(false); |
3728 | t_AST = (AST)returnAST; |
3729 | { |
3730 | if ((LA(1)==IDENT) && (LA(2)==LPAREN)) { |
3731 | AST tmp112_AST = null; |
3732 | tmp112_AST = astFactory.create(LT(1)); |
3733 | match(IDENT); |
3734 | match(LPAREN); |
3735 | parameterDeclarationList(); |
3736 | param_AST = (AST)returnAST; |
3737 | match(RPAREN); |
3738 | declaratorBrackets(t_AST); |
3739 | rt_AST = (AST)returnAST; |
3740 | { |
3741 | switch ( LA(1)) { |
3742 | case LITERAL_throws: |
3743 | { |
3744 | throwsClause(); |
3745 | tc_AST = (AST)returnAST; |
3746 | break; |
3747 | } |
3748 | case SEMI: |
3749 | case LCURLY: |
3750 | { |
3751 | break; |
3752 | } |
3753 | default: |
3754 | { |
3755 | throw new NoViableAltException(LT(1), getFilename()); |
3756 | } |
3757 | } |
3758 | } |
3759 | { |
3760 | switch ( LA(1)) { |
3761 | case LCURLY: |
3762 | { |
3763 | compoundStatement(); |
3764 | s2_AST = (AST)returnAST; |
3765 | break; |
3766 | } |
3767 | case SEMI: |
3768 | { |
3769 | AST tmp115_AST = null; |
3770 | tmp115_AST = astFactory.create(LT(1)); |
3771 | match(SEMI); |
3772 | break; |
3773 | } |
3774 | default: |
3775 | { |
3776 | throw new NoViableAltException(LT(1), getFilename()); |
3777 | } |
3778 | } |
3779 | } |
3780 | if ( inputState.guessing==0 ) { |
3781 | enumConstantField_AST = (AST)currentAST.root; |
3782 | enumConstantField_AST = (AST)astFactory.make( (new ASTArray(8)).add(astFactory.create(METHOD_DEF,"METHOD_DEF")).add(mods_AST).add(tp_AST).add((AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(TYPE,"TYPE")).add(rt_AST))).add(tmp112_AST).add(param_AST).add(tc_AST).add(s2_AST)); |
3783 | currentAST.root = enumConstantField_AST; |
3784 | currentAST.child = enumConstantField_AST!=null &&enumConstantField_AST.getFirstChild()!=null ? |
3785 | enumConstantField_AST.getFirstChild() : enumConstantField_AST; |
3786 | currentAST.advanceChildToEnd(); |
3787 | } |
3788 | } |
3789 | else if ((LA(1)==IDENT) && (_tokenSet_17.member(LA(2)))) { |
3790 | variableDefinitions(mods_AST,t_AST); |
3791 | v_AST = (AST)returnAST; |
3792 | AST tmp116_AST = null; |
3793 | tmp116_AST = astFactory.create(LT(1)); |
3794 | match(SEMI); |
3795 | if ( inputState.guessing==0 ) { |
3796 | enumConstantField_AST = (AST)currentAST.root; |
3797 | enumConstantField_AST = v_AST; |
3798 | currentAST.root = enumConstantField_AST; |
3799 | currentAST.child = enumConstantField_AST!=null &&enumConstantField_AST.getFirstChild()!=null ? |
3800 | enumConstantField_AST.getFirstChild() : enumConstantField_AST; |
3801 | currentAST.advanceChildToEnd(); |
3802 | } |
3803 | } |
3804 | else { |
3805 | throw new NoViableAltException(LT(1), getFilename()); |
3806 | } |
3807 | |
3808 | } |
3809 | break; |
3810 | } |
3811 | default: |
3812 | { |
3813 | throw new NoViableAltException(LT(1), getFilename()); |
3814 | } |
3815 | } |
3816 | } |
3817 | break; |
3818 | } |
3819 | case LCURLY: |
3820 | { |
3821 | compoundStatement(); |
3822 | s4_AST = (AST)returnAST; |
3823 | if ( inputState.guessing==0 ) { |
3824 | enumConstantField_AST = (AST)currentAST.root; |
3825 | enumConstantField_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(INSTANCE_INIT,"INSTANCE_INIT")).add(s4_AST)); |
3826 | currentAST.root = enumConstantField_AST; |
3827 | currentAST.child = enumConstantField_AST!=null &&enumConstantField_AST.getFirstChild()!=null ? |
3828 | enumConstantField_AST.getFirstChild() : enumConstantField_AST; |
3829 | currentAST.advanceChildToEnd(); |
3830 | } |
3831 | break; |
3832 | } |
3833 | default: |
3834 | { |
3835 | throw new NoViableAltException(LT(1), getFilename()); |
3836 | } |
3837 | } |
3838 | returnAST = enumConstantField_AST; |
3839 | } |
3840 | |
3841 | public final void parameterDeclarationList() throws RecognitionException, TokenStreamException { |
3842 | |
3843 | returnAST = null; |
3844 | ASTPair currentAST = new ASTPair(); |
3845 | AST parameterDeclarationList_AST = null; |
3846 | |
3847 | { |
3848 | boolean synPredMatched176 = false; |
3849 | if (((_tokenSet_18.member(LA(1))) && (_tokenSet_19.member(LA(2))))) { |
3850 | int _m176 = mark(); |
3851 | synPredMatched176 = true; |
3852 | inputState.guessing++; |
3853 | try { |
3854 | { |
3855 | parameterDeclaration(); |
3856 | } |
3857 | } |
3858 | catch (RecognitionException pe) { |
3859 | synPredMatched176 = false; |
3860 | } |
3861 | rewind(_m176); |
3862 | inputState.guessing--; |
3863 | } |
3864 | if ( synPredMatched176 ) { |
3865 | parameterDeclaration(); |
3866 | astFactory.addASTChild(currentAST, returnAST); |
3867 | { |
3868 | _loop180: |
3869 | do { |
3870 | boolean synPredMatched179 = false; |
3871 | if (((LA(1)==COMMA) && (_tokenSet_18.member(LA(2))))) { |
3872 | int _m179 = mark(); |
3873 | synPredMatched179 = true; |
3874 | inputState.guessing++; |
3875 | try { |
3876 | { |
3877 | match(COMMA); |
3878 | parameterDeclaration(); |
3879 | } |
3880 | } |
3881 | catch (RecognitionException pe) { |
3882 | synPredMatched179 = false; |
3883 | } |
3884 | rewind(_m179); |
3885 | inputState.guessing--; |
3886 | } |
3887 | if ( synPredMatched179 ) { |
3888 | match(COMMA); |
3889 | parameterDeclaration(); |
3890 | astFactory.addASTChild(currentAST, returnAST); |
3891 | } |
3892 | else { |
3893 | break _loop180; |
3894 | } |
3895 | |
3896 | } while (true); |
3897 | } |
3898 | { |
3899 | switch ( LA(1)) { |
3900 | case COMMA: |
3901 | { |
3902 | match(COMMA); |
3903 | variableLengthParameterDeclaration(); |
3904 | astFactory.addASTChild(currentAST, returnAST); |
3905 | break; |
3906 | } |
3907 | case RPAREN: |
3908 | { |
3909 | break; |
3910 | } |
3911 | default: |
3912 | { |
3913 | throw new NoViableAltException(LT(1), getFilename()); |
3914 | } |
3915 | } |
3916 | } |
3917 | } |
3918 | else if ((_tokenSet_18.member(LA(1))) && (_tokenSet_20.member(LA(2)))) { |
3919 | variableLengthParameterDeclaration(); |
3920 | astFactory.addASTChild(currentAST, returnAST); |
3921 | } |
3922 | else if ((LA(1)==RPAREN)) { |
3923 | } |
3924 | else { |
3925 | throw new NoViableAltException(LT(1), getFilename()); |
3926 | } |
3927 | |
3928 | } |
3929 | if ( inputState.guessing==0 ) { |
3930 | parameterDeclarationList_AST = (AST)currentAST.root; |
3931 | parameterDeclarationList_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(PARAMETERS,"PARAMETERS")).add(parameterDeclarationList_AST)); |
3932 | currentAST.root = parameterDeclarationList_AST; |
3933 | currentAST.child = parameterDeclarationList_AST!=null &¶meterDeclarationList_AST.getFirstChild()!=null ? |
3934 | parameterDeclarationList_AST.getFirstChild() : parameterDeclarationList_AST; |
3935 | currentAST.advanceChildToEnd(); |
3936 | } |
3937 | parameterDeclarationList_AST = (AST)currentAST.root; |
3938 | returnAST = parameterDeclarationList_AST; |
3939 | } |
3940 | |
3941 | public final void throwsClause() throws RecognitionException, TokenStreamException { |
3942 | |
3943 | returnAST = null; |
3944 | ASTPair currentAST = new ASTPair(); |
3945 | AST throwsClause_AST = null; |
3946 | |
3947 | AST tmp119_AST = null; |
3948 | tmp119_AST = astFactory.create(LT(1)); |
3949 | astFactory.makeASTRoot(currentAST, tmp119_AST); |
3950 | match(LITERAL_throws); |
3951 | identifier(); |
3952 | astFactory.addASTChild(currentAST, returnAST); |
3953 | { |
3954 | _loop172: |
3955 | do { |
3956 | if ((LA(1)==COMMA)) { |
3957 | match(COMMA); |
3958 | identifier(); |
3959 | astFactory.addASTChild(currentAST, returnAST); |
3960 | } |
3961 | else { |
3962 | break _loop172; |
3963 | } |
3964 | |
3965 | } while (true); |
3966 | } |
3967 | throwsClause_AST = (AST)currentAST.root; |
3968 | returnAST = throwsClause_AST; |
3969 | } |
3970 | |
3971 | public final void compoundStatement() throws RecognitionException, TokenStreamException { |
3972 | |
3973 | returnAST = null; |
3974 | ASTPair currentAST = new ASTPair(); |
3975 | AST compoundStatement_AST = null; |
3976 | Token lc = null; |
3977 | AST lc_AST = null; |
3978 | |
3979 | lc = LT(1); |
3980 | lc_AST = astFactory.create(lc); |
3981 | astFactory.makeASTRoot(currentAST, lc_AST); |
3982 | match(LCURLY); |
3983 | if ( inputState.guessing==0 ) { |
3984 | lc_AST.setType(SLIST); |
3985 | } |
3986 | { |
3987 | _loop192: |
3988 | do { |
3989 | if ((_tokenSet_21.member(LA(1)))) { |
3990 | statement(); |
3991 | astFactory.addASTChild(currentAST, returnAST); |
3992 | } |
3993 | else { |
3994 | break _loop192; |
3995 | } |
3996 | |
3997 | } while (true); |
3998 | } |
3999 | match(RCURLY); |
4000 | compoundStatement_AST = (AST)currentAST.root; |
4001 | returnAST = compoundStatement_AST; |
4002 | } |
4003 | |
4004 | public final void ctorHead() throws RecognitionException, TokenStreamException { |
4005 | |
4006 | returnAST = null; |
4007 | ASTPair currentAST = new ASTPair(); |
4008 | AST ctorHead_AST = null; |
4009 | |
4010 | AST tmp122_AST = null; |
4011 | tmp122_AST = astFactory.create(LT(1)); |
4012 | astFactory.addASTChild(currentAST, tmp122_AST); |
4013 | match(IDENT); |
4014 | match(LPAREN); |
4015 | parameterDeclarationList(); |
4016 | astFactory.addASTChild(currentAST, returnAST); |
4017 | match(RPAREN); |
4018 | { |
4019 | switch ( LA(1)) { |
4020 | case LITERAL_throws: |
4021 | { |
4022 | throwsClause(); |
4023 | astFactory.addASTChild(currentAST, returnAST); |
4024 | break; |
4025 | } |
4026 | case LCURLY: |
4027 | { |
4028 | break; |
4029 | } |
4030 | default: |
4031 | { |
4032 | throw new NoViableAltException(LT(1), getFilename()); |
4033 | } |
4034 | } |
4035 | } |
4036 | ctorHead_AST = (AST)currentAST.root; |
4037 | returnAST = ctorHead_AST; |
4038 | } |
4039 | |
4040 | public final void constructorBody() throws RecognitionException, TokenStreamException { |
4041 | |
4042 | returnAST = null; |
4043 | ASTPair currentAST = new ASTPair(); |
4044 | AST constructorBody_AST = null; |
4045 | Token lc = null; |
4046 | AST lc_AST = null; |
4047 | |
4048 | lc = LT(1); |
4049 | lc_AST = astFactory.create(lc); |
4050 | astFactory.makeASTRoot(currentAST, lc_AST); |
4051 | match(LCURLY); |
4052 | if ( inputState.guessing==0 ) { |
4053 | lc_AST.setType(SLIST); |
4054 | } |
4055 | { |
4056 | if ((_tokenSet_22.member(LA(1))) && (_tokenSet_23.member(LA(2)))) { |
4057 | explicitConstructorInvocation(); |
4058 | astFactory.addASTChild(currentAST, returnAST); |
4059 | } |
4060 | else if ((_tokenSet_24.member(LA(1))) && (_tokenSet_25.member(LA(2)))) { |
4061 | } |
4062 | else { |
4063 | throw new NoViableAltException(LT(1), getFilename()); |
4064 | } |
4065 | |
4066 | } |
4067 | { |
4068 | _loop149: |
4069 | do { |
4070 | if ((_tokenSet_21.member(LA(1)))) { |
4071 | statement(); |
4072 | astFactory.addASTChild(currentAST, returnAST); |
4073 | } |
4074 | else { |
4075 | break _loop149; |
4076 | } |
4077 | |
4078 | } while (true); |
4079 | } |
4080 | match(RCURLY); |
4081 | constructorBody_AST = (AST)currentAST.root; |
4082 | returnAST = constructorBody_AST; |
4083 | } |
4084 | |
4085 | /** Catch obvious constructor calls, but not the expr.super(...) calls */ |
4086 | public final void explicitConstructorInvocation() throws RecognitionException, TokenStreamException { |
4087 | |
4088 | returnAST = null; |
4089 | ASTPair currentAST = new ASTPair(); |
4090 | AST explicitConstructorInvocation_AST = null; |
4091 | Token lp1 = null; |
4092 | AST lp1_AST = null; |
4093 | Token lp2 = null; |
4094 | AST lp2_AST = null; |
4095 | |
4096 | { |
4097 | switch ( LA(1)) { |
4098 | case LT: |
4099 | { |
4100 | typeArguments(); |
4101 | astFactory.addASTChild(currentAST, returnAST); |
4102 | break; |
4103 | } |
4104 | case LITERAL_super: |
4105 | case LITERAL_this: |
4106 | { |
4107 | break; |
4108 | } |
4109 | default: |
4110 | { |
4111 | throw new NoViableAltException(LT(1), getFilename()); |
4112 | } |
4113 | } |
4114 | } |
4115 | { |
4116 | switch ( LA(1)) { |
4117 | case LITERAL_this: |
4118 | { |
4119 | match(LITERAL_this); |
4120 | lp1 = LT(1); |
4121 | lp1_AST = astFactory.create(lp1); |
4122 | astFactory.makeASTRoot(currentAST, lp1_AST); |
4123 | match(LPAREN); |
4124 | argList(); |
4125 | astFactory.addASTChild(currentAST, returnAST); |
4126 | match(RPAREN); |
4127 | match(SEMI); |
4128 | if ( inputState.guessing==0 ) { |
4129 | lp1_AST.setType(CTOR_CALL); |
4130 | } |
4131 | break; |
4132 | } |
4133 | case LITERAL_super: |
4134 | { |
4135 | match(LITERAL_super); |
4136 | lp2 = LT(1); |
4137 | lp2_AST = astFactory.create(lp2); |
4138 | astFactory.makeASTRoot(currentAST, lp2_AST); |
4139 | match(LPAREN); |
4140 | argList(); |
4141 | astFactory.addASTChild(currentAST, returnAST); |
4142 | match(RPAREN); |
4143 | match(SEMI); |
4144 | if ( inputState.guessing==0 ) { |
4145 | lp2_AST.setType(SUPER_CTOR_CALL); |
4146 | } |
4147 | break; |
4148 | } |
4149 | default: |
4150 | { |
4151 | throw new NoViableAltException(LT(1), getFilename()); |
4152 | } |
4153 | } |
4154 | } |
4155 | explicitConstructorInvocation_AST = (AST)currentAST.root; |
4156 | returnAST = explicitConstructorInvocation_AST; |
4157 | } |
4158 | |
4159 | public final void statement() throws RecognitionException, TokenStreamException { |
4160 | |
4161 | returnAST = null; |
4162 | ASTPair currentAST = new ASTPair(); |
4163 | AST statement_AST = null; |
4164 | AST m_AST = null; |
4165 | Token c = null; |
4166 | AST c_AST = null; |
4167 | Token s = null; |
4168 | AST s_AST = null; |
4169 | |
4170 | switch ( LA(1)) { |
4171 | case LCURLY: |
4172 | { |
4173 | compoundStatement(); |
4174 | astFactory.addASTChild(currentAST, returnAST); |
4175 | statement_AST = (AST)currentAST.root; |
4176 | break; |
4177 | } |
4178 | case LITERAL_if: |
4179 | { |
4180 | AST tmp132_AST = null; |
4181 | tmp132_AST = astFactory.create(LT(1)); |
4182 | astFactory.makeASTRoot(currentAST, tmp132_AST); |
4183 | match(LITERAL_if); |
4184 | match(LPAREN); |
4185 | expression(); |
4186 | astFactory.addASTChild(currentAST, returnAST); |
4187 | match(RPAREN); |
4188 | statement(); |
4189 | astFactory.addASTChild(currentAST, returnAST); |
4190 | { |
4191 | if ((LA(1)==LITERAL_else) && (_tokenSet_21.member(LA(2)))) { |
4192 | match(LITERAL_else); |
4193 | statement(); |
4194 | astFactory.addASTChild(currentAST, returnAST); |
4195 | } |
4196 | else if ((_tokenSet_26.member(LA(1))) && (_tokenSet_27.member(LA(2)))) { |
4197 | } |
4198 | else { |
4199 | throw new NoViableAltException(LT(1), getFilename()); |
4200 | } |
4201 | |
4202 | } |
4203 | statement_AST = (AST)currentAST.root; |
4204 | break; |
4205 | } |
4206 | case LITERAL_for: |
4207 | { |
4208 | forStatement(); |
4209 | astFactory.addASTChild(currentAST, returnAST); |
4210 | statement_AST = (AST)currentAST.root; |
4211 | break; |
4212 | } |
4213 | case LITERAL_while: |
4214 | { |
4215 | AST tmp136_AST = null; |
4216 | tmp136_AST = astFactory.create(LT(1)); |
4217 | astFactory.makeASTRoot(currentAST, tmp136_AST); |
4218 | match(LITERAL_while); |
4219 | match(LPAREN); |
4220 | expression(); |
4221 | astFactory.addASTChild(currentAST, returnAST); |
4222 | match(RPAREN); |
4223 | statement(); |
4224 | astFactory.addASTChild(currentAST, returnAST); |
4225 | statement_AST = (AST)currentAST.root; |
4226 | break; |
4227 | } |
4228 | case LITERAL_do: |
4229 | { |
4230 | AST tmp139_AST = null; |
4231 | tmp139_AST = astFactory.create(LT(1)); |
4232 | astFactory.makeASTRoot(currentAST, tmp139_AST); |
4233 | match(LITERAL_do); |
4234 | statement(); |
4235 | astFactory.addASTChild(currentAST, returnAST); |
4236 | match(LITERAL_while); |
4237 | match(LPAREN); |
4238 | expression(); |
4239 | astFactory.addASTChild(currentAST, returnAST); |
4240 | match(RPAREN); |
4241 | match(SEMI); |
4242 | statement_AST = (AST)currentAST.root; |
4243 | break; |
4244 | } |
4245 | case LITERAL_break: |
4246 | { |
4247 | AST tmp144_AST = null; |
4248 | tmp144_AST = astFactory.create(LT(1)); |
4249 | astFactory.makeASTRoot(currentAST, tmp144_AST); |
4250 | match(LITERAL_break); |
4251 | { |
4252 | switch ( LA(1)) { |
4253 | case IDENT: |
4254 | { |
4255 | AST tmp145_AST = null; |
4256 | tmp145_AST = astFactory.create(LT(1)); |
4257 | astFactory.addASTChild(currentAST, tmp145_AST); |
4258 | match(IDENT); |
4259 | break; |
4260 | } |
4261 | case SEMI: |
4262 | { |
4263 | break; |
4264 | } |
4265 | default: |
4266 | { |
4267 | throw new NoViableAltException(LT(1), getFilename()); |
4268 | } |
4269 | } |
4270 | } |
4271 | match(SEMI); |
4272 | statement_AST = (AST)currentAST.root; |
4273 | break; |
4274 | } |
4275 | case LITERAL_continue: |
4276 | { |
4277 | AST tmp147_AST = null; |
4278 | tmp147_AST = astFactory.create(LT(1)); |
4279 | astFactory.makeASTRoot(currentAST, tmp147_AST); |
4280 | match(LITERAL_continue); |
4281 | { |
4282 | switch ( LA(1)) { |
4283 | case IDENT: |
4284 | { |
4285 | AST tmp148_AST = null; |
4286 | tmp148_AST = astFactory.create(LT(1)); |
4287 | astFactory.addASTChild(currentAST, tmp148_AST); |
4288 | match(IDENT); |
4289 | break; |
4290 | } |
4291 | case SEMI: |
4292 | { |
4293 | break; |
4294 | } |
4295 | default: |
4296 | { |
4297 | throw new NoViableAltException(LT(1), getFilename()); |
4298 | } |
4299 | } |
4300 | } |
4301 | match(SEMI); |
4302 | statement_AST = (AST)currentAST.root; |
4303 | break; |
4304 | } |
4305 | case LITERAL_return: |
4306 | { |
4307 | AST tmp150_AST = null; |
4308 | tmp150_AST = astFactory.create(LT(1)); |
4309 | astFactory.makeASTRoot(currentAST, tmp150_AST); |
4310 | match(LITERAL_return); |
4311 | { |
4312 | switch ( LA(1)) { |
4313 | case IDENT: |
4314 | case LITERAL_super: |
4315 | case LT: |
4316 | case LITERAL_void: |
4317 | case LITERAL_boolean: |
4318 | case LITERAL_byte: |
4319 | case LITERAL_char: |
4320 | case LITERAL_short: |
4321 | case LITERAL_int: |
4322 | case LITERAL_float: |
4323 | case LITERAL_long: |
4324 | case LITERAL_double: |
4325 | case LPAREN: |
4326 | case LITERAL_this: |
4327 | case PLUS: |
4328 | case MINUS: |
4329 | case INC: |
4330 | case DEC: |
4331 | case BNOT: |
4332 | case LNOT: |
4333 | case LITERAL_true: |
4334 | case LITERAL_false: |
4335 | case LITERAL_null: |
4336 | case LITERAL_new: |
4337 | case NUM_INT: |
4338 | case CHAR_LITERAL: |
4339 | case STRING_LITERAL: |
4340 | case NUM_FLOAT: |
4341 | case NUM_LONG: |
4342 | case NUM_DOUBLE: |
4343 | { |
4344 | expression(); |
4345 | astFactory.addASTChild(currentAST, returnAST); |
4346 | break; |
4347 | } |
4348 | case SEMI: |
4349 | { |
4350 | break; |
4351 | } |
4352 | default: |
4353 | { |
4354 | throw new NoViableAltException(LT(1), getFilename()); |
4355 | } |
4356 | } |
4357 | } |
4358 | match(SEMI); |
4359 | statement_AST = (AST)currentAST.root; |
4360 | break; |
4361 | } |
4362 | case LITERAL_switch: |
4363 | { |
4364 | AST tmp152_AST = null; |
4365 | tmp152_AST = astFactory.create(LT(1)); |
4366 | astFactory.makeASTRoot(currentAST, tmp152_AST); |
4367 | match(LITERAL_switch); |
4368 | match(LPAREN); |
4369 | expression(); |
4370 | astFactory.addASTChild(currentAST, returnAST); |
4371 | match(RPAREN); |
4372 | match(LCURLY); |
4373 | { |
4374 | _loop201: |
4375 | do { |
4376 | if ((LA(1)==LITERAL_default||LA(1)==LITERAL_case)) { |
4377 | casesGroup(); |
4378 | astFactory.addASTChild(currentAST, returnAST); |
4379 | } |
4380 | else { |
4381 | break _loop201; |
4382 | } |
4383 | |
4384 | } while (true); |
4385 | } |
4386 | match(RCURLY); |
4387 | statement_AST = (AST)currentAST.root; |
4388 | break; |
4389 | } |
4390 | case LITERAL_try: |
4391 | { |
4392 | tryBlock(); |
4393 | astFactory.addASTChild(currentAST, returnAST); |
4394 | statement_AST = (AST)currentAST.root; |
4395 | break; |
4396 | } |
4397 | case LITERAL_throw: |
4398 | { |
4399 | AST tmp157_AST = null; |
4400 | tmp157_AST = astFactory.create(LT(1)); |
4401 | astFactory.makeASTRoot(currentAST, tmp157_AST); |
4402 | match(LITERAL_throw); |
4403 | expression(); |
4404 | astFactory.addASTChild(currentAST, returnAST); |
4405 | match(SEMI); |
4406 | statement_AST = (AST)currentAST.root; |
4407 | break; |
4408 | } |
4409 | case LITERAL_assert: |
4410 | { |
4411 | AST tmp159_AST = null; |
4412 | tmp159_AST = astFactory.create(LT(1)); |
4413 | astFactory.makeASTRoot(currentAST, tmp159_AST); |
4414 | match(LITERAL_assert); |
4415 | expression(); |
4416 | astFactory.addASTChild(currentAST, returnAST); |
4417 | { |
4418 | switch ( LA(1)) { |
4419 | case COLON: |
4420 | { |
4421 | match(COLON); |
4422 | expression(); |
4423 | astFactory.addASTChild(currentAST, returnAST); |
4424 | break; |
4425 | } |
4426 | case SEMI: |
4427 | { |
4428 | break; |
4429 | } |
4430 | default: |
4431 | { |
4432 | throw new NoViableAltException(LT(1), getFilename()); |
4433 | } |
4434 | } |
4435 | } |
4436 | match(SEMI); |
4437 | statement_AST = (AST)currentAST.root; |
4438 | break; |
4439 | } |
4440 | case SEMI: |
4441 | { |
4442 | s = LT(1); |
4443 | s_AST = astFactory.create(s); |
4444 | astFactory.addASTChild(currentAST, s_AST); |
4445 | match(SEMI); |
4446 | if ( inputState.guessing==0 ) { |
4447 | s_AST.setType(EMPTY_STAT); |
4448 | } |
4449 | statement_AST = (AST)currentAST.root; |
4450 | break; |
4451 | } |
4452 | default: |
4453 | boolean synPredMatched195 = false; |
4454 | if (((_tokenSet_28.member(LA(1))) && (_tokenSet_29.member(LA(2))))) { |
4455 | int _m195 = mark(); |
4456 | synPredMatched195 = true; |
4457 | inputState.guessing++; |
4458 | try { |
4459 | { |
4460 | declaration(); |
4461 | } |
4462 | } |
4463 | catch (RecognitionException pe) { |
4464 | synPredMatched195 = false; |
4465 | } |
4466 | rewind(_m195); |
4467 | inputState.guessing--; |
4468 | } |
4469 | if ( synPredMatched195 ) { |
4470 | declaration(); |
4471 | astFactory.addASTChild(currentAST, returnAST); |
4472 | match(SEMI); |
4473 | statement_AST = (AST)currentAST.root; |
4474 | } |
4475 | else if ((_tokenSet_30.member(LA(1))) && (_tokenSet_31.member(LA(2)))) { |
4476 | expression(); |
4477 | astFactory.addASTChild(currentAST, returnAST); |
4478 | match(SEMI); |
4479 | statement_AST = (AST)currentAST.root; |
4480 | } |
4481 | else if ((_tokenSet_32.member(LA(1))) && (_tokenSet_33.member(LA(2)))) { |
4482 | modifiers(); |
4483 | m_AST = (AST)returnAST; |
4484 | classDefinition(m_AST); |
4485 | astFactory.addASTChild(currentAST, returnAST); |
4486 | statement_AST = (AST)currentAST.root; |
4487 | } |
4488 | else if ((LA(1)==IDENT) && (LA(2)==COLON)) { |
4489 | AST tmp164_AST = null; |
4490 | tmp164_AST = astFactory.create(LT(1)); |
4491 | astFactory.addASTChild(currentAST, tmp164_AST); |
4492 | match(IDENT); |
4493 | c = LT(1); |
4494 | c_AST = astFactory.create(c); |
4495 | astFactory.makeASTRoot(currentAST, c_AST); |
4496 | match(COLON); |
4497 | if ( inputState.guessing==0 ) { |
4498 | c_AST.setType(LABELED_STAT); |
4499 | } |
4500 | statement(); |
4501 | astFactory.addASTChild(currentAST, returnAST); |
4502 | statement_AST = (AST)currentAST.root; |
4503 | } |
4504 | else if ((LA(1)==LITERAL_synchronized) && (LA(2)==LPAREN)) { |
4505 | AST tmp165_AST = null; |
4506 | tmp165_AST = astFactory.create(LT(1)); |
4507 | astFactory.makeASTRoot(currentAST, tmp165_AST); |
4508 | match(LITERAL_synchronized); |
4509 | match(LPAREN); |
4510 | expression(); |
4511 | astFactory.addASTChild(currentAST, returnAST); |
4512 | match(RPAREN); |
4513 | compoundStatement(); |
4514 | astFactory.addASTChild(currentAST, returnAST); |
4515 | statement_AST = (AST)currentAST.root; |
4516 | } |
4517 | else { |
4518 | throw new NoViableAltException(LT(1), getFilename()); |
4519 | } |
4520 | } |
4521 | returnAST = statement_AST; |
4522 | } |
4523 | |
4524 | /** Declaration of a variable. This can be a class/instance variable, |
4525 | * or a local variable in a method |
4526 | * It can also include possible initialization. |
4527 | */ |
4528 | public final void variableDeclarator( |
4529 | AST mods, AST t |
4530 | ) throws RecognitionException, TokenStreamException { |
4531 | |
4532 | returnAST = null; |
4533 | ASTPair currentAST = new ASTPair(); |
4534 | AST variableDeclarator_AST = null; |
4535 | Token id = null; |
4536 | AST id_AST = null; |
4537 | AST d_AST = null; |
4538 | AST v_AST = null; |
4539 | |
4540 | id = LT(1); |
4541 | id_AST = astFactory.create(id); |
4542 | match(IDENT); |
4543 | declaratorBrackets(t); |
4544 | d_AST = (AST)returnAST; |
4545 | varInitializer(); |
4546 | v_AST = (AST)returnAST; |
4547 | if ( inputState.guessing==0 ) { |
4548 | variableDeclarator_AST = (AST)currentAST.root; |
4549 | variableDeclarator_AST = (AST)astFactory.make( (new ASTArray(5)).add(astFactory.create(VARIABLE_DEF,"VARIABLE_DEF")).add(mods).add((AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(TYPE,"TYPE")).add(d_AST))).add(id_AST).add(v_AST)); |
4550 | currentAST.root = variableDeclarator_AST; |
4551 | currentAST.child = variableDeclarator_AST!=null &&variableDeclarator_AST.getFirstChild()!=null ? |
4552 | variableDeclarator_AST.getFirstChild() : variableDeclarator_AST; |
4553 | currentAST.advanceChildToEnd(); |
4554 | } |
4555 | returnAST = variableDeclarator_AST; |
4556 | } |
4557 | |
4558 | public final void varInitializer() throws RecognitionException, TokenStreamException { |
4559 | |
4560 | returnAST = null; |
4561 | ASTPair currentAST = new ASTPair(); |
4562 | AST varInitializer_AST = null; |
4563 | |
4564 | { |
4565 | switch ( LA(1)) { |
4566 | case ASSIGN: |
4567 | { |
4568 | AST tmp168_AST = null; |
4569 | tmp168_AST = astFactory.create(LT(1)); |
4570 | astFactory.makeASTRoot(currentAST, tmp168_AST); |
4571 | match(ASSIGN); |
4572 | initializer(); |
4573 | astFactory.addASTChild(currentAST, returnAST); |
4574 | break; |
4575 | } |
4576 | case SEMI: |
4577 | case COMMA: |
4578 | { |
4579 | break; |
4580 | } |
4581 | default: |
4582 | { |
4583 | throw new NoViableAltException(LT(1), getFilename()); |
4584 | } |
4585 | } |
4586 | } |
4587 | varInitializer_AST = (AST)currentAST.root; |
4588 | returnAST = varInitializer_AST; |
4589 | } |
4590 | |
4591 | public final void initializer() throws RecognitionException, TokenStreamException { |
4592 | |
4593 | returnAST = null; |
4594 | ASTPair currentAST = new ASTPair(); |
4595 | AST initializer_AST = null; |
4596 | |
4597 | switch ( LA(1)) { |
4598 | case IDENT: |
4599 | case LITERAL_super: |
4600 | case LT: |
4601 | case LITERAL_void: |
4602 | case LITERAL_boolean: |
4603 | case LITERAL_byte: |
4604 | case LITERAL_char: |
4605 | case LITERAL_short: |
4606 | case LITERAL_int: |
4607 | case LITERAL_float: |
4608 | case LITERAL_long: |
4609 | case LITERAL_double: |
4610 | case LPAREN: |
4611 | case LITERAL_this: |
4612 | case PLUS: |
4613 | case MINUS: |
4614 | case INC: |
4615 | case DEC: |
4616 | case BNOT: |
4617 | case LNOT: |
4618 | case LITERAL_true: |
4619 | case LITERAL_false: |
4620 | case LITERAL_null: |
4621 | case LITERAL_new: |
4622 | case NUM_INT: |
4623 | case CHAR_LITERAL: |
4624 | case STRING_LITERAL: |
4625 | case NUM_FLOAT: |
4626 | case NUM_LONG: |
4627 | case NUM_DOUBLE: |
4628 | { |
4629 | expression(); |
4630 | astFactory.addASTChild(currentAST, returnAST); |
4631 | initializer_AST = (AST)currentAST.root; |
4632 | break; |
4633 | } |
4634 | case LCURLY: |
4635 | { |
4636 | arrayInitializer(); |
4637 | astFactory.addASTChild(currentAST, returnAST); |
4638 | initializer_AST = (AST)currentAST.root; |
4639 | break; |
4640 | } |
4641 | default: |
4642 | { |
4643 | throw new NoViableAltException(LT(1), getFilename()); |
4644 | } |
4645 | } |
4646 | returnAST = initializer_AST; |
4647 | } |
4648 | |
4649 | public final void arrayInitializer() throws RecognitionException, TokenStreamException { |
4650 | |
4651 | returnAST = null; |
4652 | ASTPair currentAST = new ASTPair(); |
4653 | AST arrayInitializer_AST = null; |
4654 | Token lc = null; |
4655 | AST lc_AST = null; |
4656 | |
4657 | lc = LT(1); |
4658 | lc_AST = astFactory.create(lc); |
4659 | astFactory.makeASTRoot(currentAST, lc_AST); |
4660 | match(LCURLY); |
4661 | if ( inputState.guessing==0 ) { |
4662 | lc_AST.setType(ARRAY_INIT); |
4663 | } |
4664 | { |
4665 | switch ( LA(1)) { |
4666 | case IDENT: |
4667 | case LITERAL_super: |
4668 | case LT: |
4669 | case LITERAL_void: |
4670 | case LITERAL_boolean: |
4671 | case LITERAL_byte: |
4672 | case LITERAL_char: |
4673 | case LITERAL_short: |
4674 | case LITERAL_int: |
4675 | case LITERAL_float: |
4676 | case LITERAL_long: |
4677 | case LITERAL_double: |
4678 | case LPAREN: |
4679 | case LCURLY: |
4680 | case LITERAL_this: |
4681 | case PLUS: |
4682 | case MINUS: |
4683 | case INC: |
4684 | case DEC: |
4685 | case BNOT: |
4686 | case LNOT: |
4687 | case LITERAL_true: |
4688 | case LITERAL_false: |
4689 | case LITERAL_null: |
4690 | case LITERAL_new: |
4691 | case NUM_INT: |
4692 | case CHAR_LITERAL: |
4693 | case STRING_LITERAL: |
4694 | case NUM_FLOAT: |
4695 | case NUM_LONG: |
4696 | case NUM_DOUBLE: |
4697 | { |
4698 | initializer(); |
4699 | astFactory.addASTChild(currentAST, returnAST); |
4700 | { |
4701 | _loop165: |
4702 | do { |
4703 | if ((LA(1)==COMMA) && (_tokenSet_34.member(LA(2)))) { |
4704 | match(COMMA); |
4705 | initializer(); |
4706 | astFactory.addASTChild(currentAST, returnAST); |
4707 | } |
4708 | else { |
4709 | break _loop165; |
4710 | } |
4711 | |
4712 | } while (true); |
4713 | } |
4714 | { |
4715 | switch ( LA(1)) { |
4716 | case COMMA: |
4717 | { |
4718 | match(COMMA); |
4719 | break; |
4720 | } |
4721 | case RCURLY: |
4722 | { |
4723 | break; |
4724 | } |
4725 | default: |
4726 | { |
4727 | throw new NoViableAltException(LT(1), getFilename()); |
4728 | } |
4729 | } |
4730 | } |
4731 | break; |
4732 | } |
4733 | case RCURLY: |
4734 | { |
4735 | break; |
4736 | } |
4737 | default: |
4738 | { |
4739 | throw new NoViableAltException(LT(1), getFilename()); |
4740 | } |
4741 | } |
4742 | } |
4743 | match(RCURLY); |
4744 | arrayInitializer_AST = (AST)currentAST.root; |
4745 | returnAST = arrayInitializer_AST; |
4746 | } |
4747 | |
4748 | public final void expression() throws RecognitionException, TokenStreamException { |
4749 | |
4750 | returnAST = null; |
4751 | ASTPair currentAST = new ASTPair(); |
4752 | AST expression_AST = null; |
4753 | |
4754 | assignmentExpression(); |
4755 | astFactory.addASTChild(currentAST, returnAST); |
4756 | if ( inputState.guessing==0 ) { |
4757 | expression_AST = (AST)currentAST.root; |
4758 | expression_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(EXPR,"EXPR")).add(expression_AST)); |
4759 | currentAST.root = expression_AST; |
4760 | currentAST.child = expression_AST!=null &&expression_AST.getFirstChild()!=null ? |
4761 | expression_AST.getFirstChild() : expression_AST; |
4762 | currentAST.advanceChildToEnd(); |
4763 | } |
4764 | expression_AST = (AST)currentAST.root; |
4765 | returnAST = expression_AST; |
4766 | } |
4767 | |
4768 | public final void parameterDeclaration() throws RecognitionException, TokenStreamException { |
4769 | |
4770 | returnAST = null; |
4771 | ASTPair currentAST = new ASTPair(); |
4772 | AST parameterDeclaration_AST = null; |
4773 | AST pm_AST = null; |
4774 | AST t_AST = null; |
4775 | Token id = null; |
4776 | AST id_AST = null; |
4777 | AST pd_AST = null; |
4778 | |
4779 | parameterModifier(); |
4780 | pm_AST = (AST)returnAST; |
4781 | typeSpec(false); |
4782 | t_AST = (AST)returnAST; |
4783 | id = LT(1); |
4784 | id_AST = astFactory.create(id); |
4785 | match(IDENT); |
4786 | declaratorBrackets(t_AST); |
4787 | pd_AST = (AST)returnAST; |
4788 | if ( inputState.guessing==0 ) { |
4789 | parameterDeclaration_AST = (AST)currentAST.root; |
4790 | parameterDeclaration_AST = (AST)astFactory.make( (new ASTArray(4)).add(astFactory.create(PARAMETER_DEF,"PARAMETER_DEF")).add(pm_AST).add((AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(TYPE,"TYPE")).add(pd_AST))).add(id_AST)); |
4791 | currentAST.root = parameterDeclaration_AST; |
4792 | currentAST.child = parameterDeclaration_AST!=null &¶meterDeclaration_AST.getFirstChild()!=null ? |
4793 | parameterDeclaration_AST.getFirstChild() : parameterDeclaration_AST; |
4794 | currentAST.advanceChildToEnd(); |
4795 | } |
4796 | returnAST = parameterDeclaration_AST; |
4797 | } |
4798 | |
4799 | public final void variableLengthParameterDeclaration() throws RecognitionException, TokenStreamException { |
4800 | |
4801 | returnAST = null; |
4802 | ASTPair currentAST = new ASTPair(); |
4803 | AST variableLengthParameterDeclaration_AST = null; |
4804 | AST pm_AST = null; |
4805 | AST t_AST = null; |
4806 | Token id = null; |
4807 | AST id_AST = null; |
4808 | AST pd_AST = null; |
4809 | |
4810 | parameterModifier(); |
4811 | pm_AST = (AST)returnAST; |
4812 | typeSpec(false); |
4813 | t_AST = (AST)returnAST; |
4814 | match(TRIPLE_DOT); |
4815 | id = LT(1); |
4816 | id_AST = astFactory.create(id); |
4817 | match(IDENT); |
4818 | declaratorBrackets(t_AST); |
4819 | pd_AST = (AST)returnAST; |
4820 | if ( inputState.guessing==0 ) { |
4821 | variableLengthParameterDeclaration_AST = (AST)currentAST.root; |
4822 | variableLengthParameterDeclaration_AST = (AST)astFactory.make( (new ASTArray(4)).add(astFactory.create(VARIABLE_PARAMETER_DEF,"VARIABLE_PARAMETER_DEF")).add(pm_AST).add((AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(TYPE,"TYPE")).add(pd_AST))).add(id_AST)); |
4823 | currentAST.root = variableLengthParameterDeclaration_AST; |
4824 | currentAST.child = variableLengthParameterDeclaration_AST!=null &&variableLengthParameterDeclaration_AST.getFirstChild()!=null ? |
4825 | variableLengthParameterDeclaration_AST.getFirstChild() : variableLengthParameterDeclaration_AST; |
4826 | currentAST.advanceChildToEnd(); |
4827 | } |
4828 | returnAST = variableLengthParameterDeclaration_AST; |
4829 | } |
4830 | |
4831 | public final void parameterModifier() throws RecognitionException, TokenStreamException { |
4832 | |
4833 | returnAST = null; |
4834 | ASTPair currentAST = new ASTPair(); |
4835 | AST parameterModifier_AST = null; |
4836 | Token f = null; |
4837 | AST f_AST = null; |
4838 | |
4839 | { |
4840 | _loop186: |
4841 | do { |
4842 | if ((LA(1)==AT) && (LA(2)==IDENT)) { |
4843 | annotation(); |
4844 | astFactory.addASTChild(currentAST, returnAST); |
4845 | } |
4846 | else { |
4847 | break _loop186; |
4848 | } |
4849 | |
4850 | } while (true); |
4851 | } |
4852 | { |
4853 | switch ( LA(1)) { |
4854 | case FINAL: |
4855 | { |
4856 | f = LT(1); |
4857 | f_AST = astFactory.create(f); |
4858 | astFactory.addASTChild(currentAST, f_AST); |
4859 | match(FINAL); |
4860 | break; |
4861 | } |
4862 | case IDENT: |
4863 | case LITERAL_void: |
4864 | case LITERAL_boolean: |
4865 | case LITERAL_byte: |
4866 | case LITERAL_char: |
4867 | case LITERAL_short: |
4868 | case LITERAL_int: |
4869 | case LITERAL_float: |
4870 | case LITERAL_long: |
4871 | case LITERAL_double: |
4872 | case AT: |
4873 | { |
4874 | break; |
4875 | } |
4876 | default: |
4877 | { |
4878 | throw new NoViableAltException(LT(1), getFilename()); |
4879 | } |
4880 | } |
4881 | } |
4882 | { |
4883 | _loop189: |
4884 | do { |
4885 | if ((LA(1)==AT)) { |
4886 | annotation(); |
4887 | astFactory.addASTChild(currentAST, returnAST); |
4888 | } |
4889 | else { |
4890 | break _loop189; |
4891 | } |
4892 | |
4893 | } while (true); |
4894 | } |
4895 | if ( inputState.guessing==0 ) { |
4896 | parameterModifier_AST = (AST)currentAST.root; |
4897 | parameterModifier_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(MODIFIERS,"MODIFIERS")).add(parameterModifier_AST)); |
4898 | currentAST.root = parameterModifier_AST; |
4899 | currentAST.child = parameterModifier_AST!=null &¶meterModifier_AST.getFirstChild()!=null ? |
4900 | parameterModifier_AST.getFirstChild() : parameterModifier_AST; |
4901 | currentAST.advanceChildToEnd(); |
4902 | } |
4903 | parameterModifier_AST = (AST)currentAST.root; |
4904 | returnAST = parameterModifier_AST; |
4905 | } |
4906 | |
4907 | public final void forStatement() throws RecognitionException, TokenStreamException { |
4908 | |
4909 | returnAST = null; |
4910 | ASTPair currentAST = new ASTPair(); |
4911 | AST forStatement_AST = null; |
4912 | Token f = null; |
4913 | AST f_AST = null; |
4914 | |
4915 | f = LT(1); |
4916 | f_AST = astFactory.create(f); |
4917 | astFactory.makeASTRoot(currentAST, f_AST); |
4918 | match(LITERAL_for); |
4919 | match(LPAREN); |
4920 | { |
4921 | boolean synPredMatched206 = false; |
4922 | if (((_tokenSet_35.member(LA(1))) && (_tokenSet_36.member(LA(2))))) { |
4923 | int _m206 = mark(); |
4924 | synPredMatched206 = true; |
4925 | inputState.guessing++; |
4926 | try { |
4927 | { |
4928 | forInit(); |
4929 | match(SEMI); |
4930 | } |
4931 | } |
4932 | catch (RecognitionException pe) { |
4933 | synPredMatched206 = false; |
4934 | } |
4935 | rewind(_m206); |
4936 | inputState.guessing--; |
4937 | } |
4938 | if ( synPredMatched206 ) { |
4939 | traditionalForClause(); |
4940 | astFactory.addASTChild(currentAST, returnAST); |
4941 | } |
4942 | else if ((_tokenSet_18.member(LA(1))) && (_tokenSet_19.member(LA(2)))) { |
4943 | forEachClause(); |
4944 | astFactory.addASTChild(currentAST, returnAST); |
4945 | } |
4946 | else { |
4947 | throw new NoViableAltException(LT(1), getFilename()); |
4948 | } |
4949 | |
4950 | } |
4951 | match(RPAREN); |
4952 | statement(); |
4953 | astFactory.addASTChild(currentAST, returnAST); |
4954 | forStatement_AST = (AST)currentAST.root; |
4955 | returnAST = forStatement_AST; |
4956 | } |
4957 | |
4958 | public final void casesGroup() throws RecognitionException, TokenStreamException { |
4959 | |
4960 | returnAST = null; |
4961 | ASTPair currentAST = new ASTPair(); |
4962 | AST casesGroup_AST = null; |
4963 | |
4964 | { |
4965 | int _cnt211=0; |
4966 | _loop211: |
4967 | do { |
4968 | if ((LA(1)==LITERAL_default||LA(1)==LITERAL_case) && (_tokenSet_37.member(LA(2)))) { |
4969 | aCase(); |
4970 | astFactory.addASTChild(currentAST, returnAST); |
4971 | } |
4972 | else { |
4973 | if ( _cnt211>=1 ) { break _loop211; } else {throw new NoViableAltException(LT(1), getFilename());} |
4974 | } |
4975 | |
4976 | _cnt211++; |
4977 | } while (true); |
4978 | } |
4979 | caseSList(); |
4980 | astFactory.addASTChild(currentAST, returnAST); |
4981 | if ( inputState.guessing==0 ) { |
4982 | casesGroup_AST = (AST)currentAST.root; |
4983 | casesGroup_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(CASE_GROUP,"CASE_GROUP")).add(casesGroup_AST)); |
4984 | currentAST.root = casesGroup_AST; |
4985 | currentAST.child = casesGroup_AST!=null &&casesGroup_AST.getFirstChild()!=null ? |
4986 | casesGroup_AST.getFirstChild() : casesGroup_AST; |
4987 | currentAST.advanceChildToEnd(); |
4988 | } |
4989 | casesGroup_AST = (AST)currentAST.root; |
4990 | returnAST = casesGroup_AST; |
4991 | } |
4992 | |
4993 | public final void tryBlock() throws RecognitionException, TokenStreamException { |
4994 | |
4995 | returnAST = null; |
4996 | ASTPair currentAST = new ASTPair(); |
4997 | AST tryBlock_AST = null; |
4998 | |
4999 | AST tmp175_AST = null; |
5000 | tmp175_AST = astFactory.create(LT(1)); |
5001 | astFactory.makeASTRoot(currentAST, tmp175_AST); |
5002 | match(LITERAL_try); |
5003 | compoundStatement(); |
5004 | astFactory.addASTChild(currentAST, returnAST); |
5005 | { |
5006 | _loop227: |
5007 | do { |
5008 | if ((LA(1)==LITERAL_catch)) { |
5009 | handler(); |
5010 | astFactory.addASTChild(currentAST, returnAST); |
5011 | } |
5012 | else { |
5013 | break _loop227; |
5014 | } |
5015 | |
5016 | } while (true); |
5017 | } |
5018 | { |
5019 | switch ( LA(1)) { |
5020 | case LITERAL_finally: |
5021 | { |
5022 | finallyClause(); |
5023 | astFactory.addASTChild(currentAST, returnAST); |
5024 | break; |
5025 | } |
5026 | case FINAL: |
5027 | case ABSTRACT: |
5028 | case STRICTFP: |
5029 | case SEMI: |
5030 | case LITERAL_static: |
5031 | case IDENT: |
5032 | case LITERAL_super: |
5033 | case LT: |
5034 | case LITERAL_void: |
5035 | case LITERAL_boolean: |
5036 | case LITERAL_byte: |
5037 | case LITERAL_char: |
5038 | case LITERAL_short: |
5039 | case LITERAL_int: |
5040 | case LITERAL_float: |
5041 | case LITERAL_long: |
5042 | case LITERAL_double: |
5043 | case LITERAL_private: |
5044 | case LITERAL_public: |
5045 | case LITERAL_protected: |
5046 | case LITERAL_transient: |
5047 | case LITERAL_native: |
5048 | case LITERAL_threadsafe: |
5049 | case LITERAL_synchronized: |
5050 | case LITERAL_volatile: |
5051 | case AT: |
5052 | case LPAREN: |
5053 | case LCURLY: |
5054 | case RCURLY: |
5055 | case LITERAL_class: |
5056 | case LITERAL_default: |
5057 | case LITERAL_this: |
5058 | case LITERAL_if: |
5059 | case LITERAL_else: |
5060 | case LITERAL_while: |
5061 | case LITERAL_do: |
5062 | case LITERAL_break: |
5063 | case LITERAL_continue: |
5064 | case LITERAL_return: |
5065 | case LITERAL_switch: |
5066 | case LITERAL_throw: |
5067 | case LITERAL_assert: |
5068 | case LITERAL_for: |
5069 | case LITERAL_case: |
5070 | case LITERAL_try: |
5071 | case PLUS: |
5072 | case MINUS: |
5073 | case INC: |
5074 | case DEC: |
5075 | case BNOT: |
5076 | case LNOT: |
5077 | case LITERAL_true: |
5078 | case LITERAL_false: |
5079 | case LITERAL_null: |
5080 | case LITERAL_new: |
5081 | case NUM_INT: |
5082 | case CHAR_LITERAL: |
5083 | case STRING_LITERAL: |
5084 | case NUM_FLOAT: |
5085 | case NUM_LONG: |
5086 | case NUM_DOUBLE: |
5087 | { |
5088 | break; |
5089 | } |
5090 | default: |
5091 | { |
5092 | throw new NoViableAltException(LT(1), getFilename()); |
5093 | } |
5094 | } |
5095 | } |
5096 | tryBlock_AST = (AST)currentAST.root; |
5097 | returnAST = tryBlock_AST; |
5098 | } |
5099 | |
5100 | public final void forInit() throws RecognitionException, TokenStreamException { |
5101 | |
5102 | returnAST = null; |
5103 | ASTPair currentAST = new ASTPair(); |
5104 | AST forInit_AST = null; |
5105 | |
5106 | { |
5107 | boolean synPredMatched220 = false; |
5108 | if (((_tokenSet_28.member(LA(1))) && (_tokenSet_29.member(LA(2))))) { |
5109 | int _m220 = mark(); |
5110 | synPredMatched220 = true; |
5111 | inputState.guessing++; |
5112 | try { |
5113 | { |
5114 | declaration(); |
5115 | } |
5116 | } |
5117 | catch (RecognitionException pe) { |
5118 | synPredMatched220 = false; |
5119 | } |
5120 | rewind(_m220); |
5121 | inputState.guessing--; |
5122 | } |
5123 | if ( synPredMatched220 ) { |
5124 | declaration(); |
5125 | astFactory.addASTChild(currentAST, returnAST); |
5126 | } |
5127 | else if ((_tokenSet_30.member(LA(1))) && (_tokenSet_38.member(LA(2)))) { |
5128 | expressionList(); |
5129 | astFactory.addASTChild(currentAST, returnAST); |
5130 | } |
5131 | else if ((LA(1)==SEMI)) { |
5132 | } |
5133 | else { |
5134 | throw new NoViableAltException(LT(1), getFilename()); |
5135 | } |
5136 | |
5137 | } |
5138 | if ( inputState.guessing==0 ) { |
5139 | forInit_AST = (AST)currentAST.root; |
5140 | forInit_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(FOR_INIT,"FOR_INIT")).add(forInit_AST)); |
5141 | currentAST.root = forInit_AST; |
5142 | currentAST.child = forInit_AST!=null &&forInit_AST.getFirstChild()!=null ? |
5143 | forInit_AST.getFirstChild() : forInit_AST; |
5144 | currentAST.advanceChildToEnd(); |
5145 | } |
5146 | forInit_AST = (AST)currentAST.root; |
5147 | returnAST = forInit_AST; |
5148 | } |
5149 | |
5150 | public final void traditionalForClause() throws RecognitionException, TokenStreamException { |
5151 | |
5152 | returnAST = null; |
5153 | ASTPair currentAST = new ASTPair(); |
5154 | AST traditionalForClause_AST = null; |
5155 | |
5156 | forInit(); |
5157 | astFactory.addASTChild(currentAST, returnAST); |
5158 | match(SEMI); |
5159 | forCond(); |
5160 | astFactory.addASTChild(currentAST, returnAST); |
5161 | match(SEMI); |
5162 | forIter(); |
5163 | astFactory.addASTChild(currentAST, returnAST); |
5164 | traditionalForClause_AST = (AST)currentAST.root; |
5165 | returnAST = traditionalForClause_AST; |
5166 | } |
5167 | |
5168 | public final void forEachClause() throws RecognitionException, TokenStreamException { |
5169 | |
5170 | returnAST = null; |
5171 | ASTPair currentAST = new ASTPair(); |
5172 | AST forEachClause_AST = null; |
5173 | AST p_AST = null; |
5174 | |
5175 | parameterDeclaration(); |
5176 | p_AST = (AST)returnAST; |
5177 | astFactory.addASTChild(currentAST, returnAST); |
5178 | match(COLON); |
5179 | expression(); |
5180 | astFactory.addASTChild(currentAST, returnAST); |
5181 | if ( inputState.guessing==0 ) { |
5182 | forEachClause_AST = (AST)currentAST.root; |
5183 | forEachClause_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(FOR_EACH_CLAUSE,"FOR_EACH_CLAUSE")).add(forEachClause_AST)); |
5184 | currentAST.root = forEachClause_AST; |
5185 | currentAST.child = forEachClause_AST!=null &&forEachClause_AST.getFirstChild()!=null ? |
5186 | forEachClause_AST.getFirstChild() : forEachClause_AST; |
5187 | currentAST.advanceChildToEnd(); |
5188 | } |
5189 | forEachClause_AST = (AST)currentAST.root; |
5190 | returnAST = forEachClause_AST; |
5191 | } |
5192 | |
5193 | public final void forCond() throws RecognitionException, TokenStreamException { |
5194 | |
5195 | returnAST = null; |
5196 | ASTPair currentAST = new ASTPair(); |
5197 | AST forCond_AST = null; |
5198 | |
5199 | { |
5200 | switch ( LA(1)) { |
5201 | case IDENT: |
5202 | case LITERAL_super: |
5203 | case LT: |
5204 | case LITERAL_void: |
5205 | case LITERAL_boolean: |
5206 | case LITERAL_byte: |
5207 | case LITERAL_char: |
5208 | case LITERAL_short: |
5209 | case LITERAL_int: |
5210 | case LITERAL_float: |
5211 | case LITERAL_long: |
5212 | case LITERAL_double: |
5213 | case LPAREN: |
5214 | case LITERAL_this: |
5215 | case PLUS: |
5216 | case MINUS: |
5217 | case INC: |
5218 | case DEC: |
5219 | case BNOT: |
5220 | case LNOT: |
5221 | case LITERAL_true: |
5222 | case LITERAL_false: |
5223 | case LITERAL_null: |
5224 | case LITERAL_new: |
5225 | case NUM_INT: |
5226 | case CHAR_LITERAL: |
5227 | case STRING_LITERAL: |
5228 | case NUM_FLOAT: |
5229 | case NUM_LONG: |
5230 | case NUM_DOUBLE: |
5231 | { |
5232 | expression(); |
5233 | astFactory.addASTChild(currentAST, returnAST); |
5234 | break; |
5235 | } |
5236 | case SEMI: |
5237 | { |
5238 | break; |
5239 | } |
5240 | default: |
5241 | { |
5242 | throw new NoViableAltException(LT(1), getFilename()); |
5243 | } |
5244 | } |
5245 | } |
5246 | if ( inputState.guessing==0 ) { |
5247 | forCond_AST = (AST)currentAST.root; |
5248 | forCond_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(FOR_CONDITION,"FOR_CONDITION")).add(forCond_AST)); |
5249 | currentAST.root = forCond_AST; |
5250 | currentAST.child = forCond_AST!=null &&forCond_AST.getFirstChild()!=null ? |
5251 | forCond_AST.getFirstChild() : forCond_AST; |
5252 | currentAST.advanceChildToEnd(); |
5253 | } |
5254 | forCond_AST = (AST)currentAST.root; |
5255 | returnAST = forCond_AST; |
5256 | } |
5257 | |
5258 | public final void forIter() throws RecognitionException, TokenStreamException { |
5259 | |
5260 | returnAST = null; |
5261 | ASTPair currentAST = new ASTPair(); |
5262 | AST forIter_AST = null; |
5263 | |
5264 | { |
5265 | switch ( LA(1)) { |
5266 | case IDENT: |
5267 | case LITERAL_super: |
5268 | case LT: |
5269 | case LITERAL_void: |
5270 | case LITERAL_boolean: |
5271 | case LITERAL_byte: |
5272 | case LITERAL_char: |
5273 | case LITERAL_short: |
5274 | case LITERAL_int: |
5275 | case LITERAL_float: |
5276 | case LITERAL_long: |
5277 | case LITERAL_double: |
5278 | case LPAREN: |
5279 | case LITERAL_this: |
5280 | case PLUS: |
5281 | case MINUS: |
5282 | case INC: |
5283 | case DEC: |
5284 | case BNOT: |
5285 | case LNOT: |
5286 | case LITERAL_true: |
5287 | case LITERAL_false: |
5288 | case LITERAL_null: |
5289 | case LITERAL_new: |
5290 | case NUM_INT: |
5291 | case CHAR_LITERAL: |
5292 | case STRING_LITERAL: |
5293 | case NUM_FLOAT: |
5294 | case NUM_LONG: |
5295 | case NUM_DOUBLE: |
5296 | { |
5297 | expressionList(); |
5298 | astFactory.addASTChild(currentAST, returnAST); |
5299 | break; |
5300 | } |
5301 | case RPAREN: |
5302 | { |
5303 | break; |
5304 | } |
5305 | default: |
5306 | { |
5307 | throw new NoViableAltException(LT(1), getFilename()); |
5308 | } |
5309 | } |
5310 | } |
5311 | if ( inputState.guessing==0 ) { |
5312 | forIter_AST = (AST)currentAST.root; |
5313 | forIter_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(FOR_ITERATOR,"FOR_ITERATOR")).add(forIter_AST)); |
5314 | currentAST.root = forIter_AST; |
5315 | currentAST.child = forIter_AST!=null &&forIter_AST.getFirstChild()!=null ? |
5316 | forIter_AST.getFirstChild() : forIter_AST; |
5317 | currentAST.advanceChildToEnd(); |
5318 | } |
5319 | forIter_AST = (AST)currentAST.root; |
5320 | returnAST = forIter_AST; |
5321 | } |
5322 | |
5323 | public final void aCase() throws RecognitionException, TokenStreamException { |
5324 | |
5325 | returnAST = null; |
5326 | ASTPair currentAST = new ASTPair(); |
5327 | AST aCase_AST = null; |
5328 | |
5329 | { |
5330 | switch ( LA(1)) { |
5331 | case LITERAL_case: |
5332 | { |
5333 | AST tmp179_AST = null; |
5334 | tmp179_AST = astFactory.create(LT(1)); |
5335 | astFactory.makeASTRoot(currentAST, tmp179_AST); |
5336 | match(LITERAL_case); |
5337 | expression(); |
5338 | astFactory.addASTChild(currentAST, returnAST); |
5339 | break; |
5340 | } |
5341 | case LITERAL_default: |
5342 | { |
5343 | AST tmp180_AST = null; |
5344 | tmp180_AST = astFactory.create(LT(1)); |
5345 | astFactory.addASTChild(currentAST, tmp180_AST); |
5346 | match(LITERAL_default); |
5347 | break; |
5348 | } |
5349 | default: |
5350 | { |
5351 | throw new NoViableAltException(LT(1), getFilename()); |
5352 | } |
5353 | } |
5354 | } |
5355 | match(COLON); |
5356 | aCase_AST = (AST)currentAST.root; |
5357 | returnAST = aCase_AST; |
5358 | } |
5359 | |
5360 | public final void caseSList() throws RecognitionException, TokenStreamException { |
5361 | |
5362 | returnAST = null; |
5363 | ASTPair currentAST = new ASTPair(); |
5364 | AST caseSList_AST = null; |
5365 | |
5366 | { |
5367 | _loop216: |
5368 | do { |
5369 | if ((_tokenSet_21.member(LA(1)))) { |
5370 | statement(); |
5371 | astFactory.addASTChild(currentAST, returnAST); |
5372 | } |
5373 | else { |
5374 | break _loop216; |
5375 | } |
5376 | |
5377 | } while (true); |
5378 | } |
5379 | if ( inputState.guessing==0 ) { |
5380 | caseSList_AST = (AST)currentAST.root; |
5381 | caseSList_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(SLIST,"SLIST")).add(caseSList_AST)); |
5382 | currentAST.root = caseSList_AST; |
5383 | currentAST.child = caseSList_AST!=null &&caseSList_AST.getFirstChild()!=null ? |
5384 | caseSList_AST.getFirstChild() : caseSList_AST; |
5385 | currentAST.advanceChildToEnd(); |
5386 | } |
5387 | caseSList_AST = (AST)currentAST.root; |
5388 | returnAST = caseSList_AST; |
5389 | } |
5390 | |
5391 | public final void expressionList() throws RecognitionException, TokenStreamException { |
5392 | |
5393 | returnAST = null; |
5394 | ASTPair currentAST = new ASTPair(); |
5395 | AST expressionList_AST = null; |
5396 | |
5397 | expression(); |
5398 | astFactory.addASTChild(currentAST, returnAST); |
5399 | { |
5400 | _loop234: |
5401 | do { |
5402 | if ((LA(1)==COMMA)) { |
5403 | match(COMMA); |
5404 | expression(); |
5405 | astFactory.addASTChild(currentAST, returnAST); |
5406 | } |
5407 | else { |
5408 | break _loop234; |
5409 | } |
5410 | |
5411 | } while (true); |
5412 | } |
5413 | if ( inputState.guessing==0 ) { |
5414 | expressionList_AST = (AST)currentAST.root; |
5415 | expressionList_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(ELIST,"ELIST")).add(expressionList_AST)); |
5416 | currentAST.root = expressionList_AST; |
5417 | currentAST.child = expressionList_AST!=null &&expressionList_AST.getFirstChild()!=null ? |
5418 | expressionList_AST.getFirstChild() : expressionList_AST; |
5419 | currentAST.advanceChildToEnd(); |
5420 | } |
5421 | expressionList_AST = (AST)currentAST.root; |
5422 | returnAST = expressionList_AST; |
5423 | } |
5424 | |
5425 | public final void handler() throws RecognitionException, TokenStreamException { |
5426 | |
5427 | returnAST = null; |
5428 | ASTPair currentAST = new ASTPair(); |
5429 | AST handler_AST = null; |
5430 | |
5431 | AST tmp183_AST = null; |
5432 | tmp183_AST = astFactory.create(LT(1)); |
5433 | astFactory.makeASTRoot(currentAST, tmp183_AST); |
5434 | match(LITERAL_catch); |
5435 | match(LPAREN); |
5436 | parameterDeclaration(); |
5437 | astFactory.addASTChild(currentAST, returnAST); |
5438 | match(RPAREN); |
5439 | compoundStatement(); |
5440 | astFactory.addASTChild(currentAST, returnAST); |
5441 | handler_AST = (AST)currentAST.root; |
5442 | returnAST = handler_AST; |
5443 | } |
5444 | |
5445 | public final void finallyClause() throws RecognitionException, TokenStreamException { |
5446 | |
5447 | returnAST = null; |
5448 | ASTPair currentAST = new ASTPair(); |
5449 | AST finallyClause_AST = null; |
5450 | |
5451 | AST tmp186_AST = null; |
5452 | tmp186_AST = astFactory.create(LT(1)); |
5453 | astFactory.makeASTRoot(currentAST, tmp186_AST); |
5454 | match(LITERAL_finally); |
5455 | compoundStatement(); |
5456 | astFactory.addASTChild(currentAST, returnAST); |
5457 | finallyClause_AST = (AST)currentAST.root; |
5458 | returnAST = finallyClause_AST; |
5459 | } |
5460 | |
5461 | public final void assignmentExpression() throws RecognitionException, TokenStreamException { |
5462 | |
5463 | returnAST = null; |
5464 | ASTPair currentAST = new ASTPair(); |
5465 | AST assignmentExpression_AST = null; |
5466 | |
5467 | conditionalExpression(); |
5468 | astFactory.addASTChild(currentAST, returnAST); |
5469 | { |
5470 | switch ( LA(1)) { |
5471 | case ASSIGN: |
5472 | case PLUS_ASSIGN: |
5473 | case MINUS_ASSIGN: |
5474 | case STAR_ASSIGN: |
5475 | case DIV_ASSIGN: |
5476 | case MOD_ASSIGN: |
5477 | case SR_ASSIGN: |
5478 | case BSR_ASSIGN: |
5479 | case SL_ASSIGN: |
5480 | case BAND_ASSIGN: |
5481 | case BXOR_ASSIGN: |
5482 | case BOR_ASSIGN: |
5483 | { |
5484 | { |
5485 | switch ( LA(1)) { |
5486 | case ASSIGN: |
5487 | { |
5488 | AST tmp187_AST = null; |
5489 | tmp187_AST = astFactory.create(LT(1)); |
5490 | astFactory.makeASTRoot(currentAST, tmp187_AST); |
5491 | match(ASSIGN); |
5492 | break; |
5493 | } |
5494 | case PLUS_ASSIGN: |
5495 | { |
5496 | AST tmp188_AST = null; |
5497 | tmp188_AST = astFactory.create(LT(1)); |
5498 | astFactory.makeASTRoot(currentAST, tmp188_AST); |
5499 | match(PLUS_ASSIGN); |
5500 | break; |
5501 | } |
5502 | case MINUS_ASSIGN: |
5503 | { |
5504 | AST tmp189_AST = null; |
5505 | tmp189_AST = astFactory.create(LT(1)); |
5506 | astFactory.makeASTRoot(currentAST, tmp189_AST); |
5507 | match(MINUS_ASSIGN); |
5508 | break; |
5509 | } |
5510 | case STAR_ASSIGN: |
5511 | { |
5512 | AST tmp190_AST = null; |
5513 | tmp190_AST = astFactory.create(LT(1)); |
5514 | astFactory.makeASTRoot(currentAST, tmp190_AST); |
5515 | match(STAR_ASSIGN); |
5516 | break; |
5517 | } |
5518 | case DIV_ASSIGN: |
5519 | { |
5520 | AST tmp191_AST = null; |
5521 | tmp191_AST = astFactory.create(LT(1)); |
5522 | astFactory.makeASTRoot(currentAST, tmp191_AST); |
5523 | match(DIV_ASSIGN); |
5524 | break; |
5525 | } |
5526 | case MOD_ASSIGN: |
5527 | { |
5528 | AST tmp192_AST = null; |
5529 | tmp192_AST = astFactory.create(LT(1)); |
5530 | astFactory.makeASTRoot(currentAST, tmp192_AST); |
5531 | match(MOD_ASSIGN); |
5532 | break; |
5533 | } |
5534 | case SR_ASSIGN: |
5535 | { |
5536 | AST tmp193_AST = null; |
5537 | tmp193_AST = astFactory.create(LT(1)); |
5538 | astFactory.makeASTRoot(currentAST, tmp193_AST); |
5539 | match(SR_ASSIGN); |
5540 | break; |
5541 | } |
5542 | case BSR_ASSIGN: |
5543 | { |
5544 | AST tmp194_AST = null; |
5545 | tmp194_AST = astFactory.create(LT(1)); |
5546 | astFactory.makeASTRoot(currentAST, tmp194_AST); |
5547 | match(BSR_ASSIGN); |
5548 | break; |
5549 | } |
5550 | case SL_ASSIGN: |
5551 | { |
5552 | AST tmp195_AST = null; |
5553 | tmp195_AST = astFactory.create(LT(1)); |
5554 | astFactory.makeASTRoot(currentAST, tmp195_AST); |
5555 | match(SL_ASSIGN); |
5556 | break; |
5557 | } |
5558 | case BAND_ASSIGN: |
5559 | { |
5560 | AST tmp196_AST = null; |
5561 | tmp196_AST = astFactory.create(LT(1)); |
5562 | astFactory.makeASTRoot(currentAST, tmp196_AST); |
5563 | match(BAND_ASSIGN); |
5564 | break; |
5565 | } |
5566 | case BXOR_ASSIGN: |
5567 | { |
5568 | AST tmp197_AST = null; |
5569 | tmp197_AST = astFactory.create(LT(1)); |
5570 | astFactory.makeASTRoot(currentAST, tmp197_AST); |
5571 | match(BXOR_ASSIGN); |
5572 | break; |
5573 | } |
5574 | case BOR_ASSIGN: |
5575 | { |
5576 | AST tmp198_AST = null; |
5577 | tmp198_AST = astFactory.create(LT(1)); |
5578 | astFactory.makeASTRoot(currentAST, tmp198_AST); |
5579 | match(BOR_ASSIGN); |
5580 | break; |
5581 | } |
5582 | default: |
5583 | { |
5584 | throw new NoViableAltException(LT(1), getFilename()); |
5585 | } |
5586 | } |
5587 | } |
5588 | assignmentExpression(); |
5589 | astFactory.addASTChild(currentAST, returnAST); |
5590 | break; |
5591 | } |
5592 | case SEMI: |
5593 | case RBRACK: |
5594 | case COMMA: |
5595 | case RPAREN: |
5596 | case RCURLY: |
5597 | case COLON: |
5598 | { |
5599 | break; |
5600 | } |
5601 | default: |
5602 | { |
5603 | throw new NoViableAltException(LT(1), getFilename()); |
5604 | } |
5605 | } |
5606 | } |
5607 | assignmentExpression_AST = (AST)currentAST.root; |
5608 | returnAST = assignmentExpression_AST; |
5609 | } |
5610 | |
5611 | public final void logicalOrExpression() throws RecognitionException, TokenStreamException { |
5612 | |
5613 | returnAST = null; |
5614 | ASTPair currentAST = new ASTPair(); |
5615 | AST logicalOrExpression_AST = null; |
5616 | |
5617 | logicalAndExpression(); |
5618 | astFactory.addASTChild(currentAST, returnAST); |
5619 | { |
5620 | _loop242: |
5621 | do { |
5622 | if ((LA(1)==LOR)) { |
5623 | AST tmp199_AST = null; |
5624 | tmp199_AST = astFactory.create(LT(1)); |
5625 | astFactory.makeASTRoot(currentAST, tmp199_AST); |
5626 | match(LOR); |
5627 | logicalAndExpression(); |
5628 | astFactory.addASTChild(currentAST, returnAST); |
5629 | } |
5630 | else { |
5631 | break _loop242; |
5632 | } |
5633 | |
5634 | } while (true); |
5635 | } |
5636 | logicalOrExpression_AST = (AST)currentAST.root; |
5637 | returnAST = logicalOrExpression_AST; |
5638 | } |
5639 | |
5640 | public final void logicalAndExpression() throws RecognitionException, TokenStreamException { |
5641 | |
5642 | returnAST = null; |
5643 | ASTPair currentAST = new ASTPair(); |
5644 | AST logicalAndExpression_AST = null; |
5645 | |
5646 | inclusiveOrExpression(); |
5647 | astFactory.addASTChild(currentAST, returnAST); |
5648 | { |
5649 | _loop245: |
5650 | do { |
5651 | if ((LA(1)==LAND)) { |
5652 | AST tmp200_AST = null; |
5653 | tmp200_AST = astFactory.create(LT(1)); |
5654 | astFactory.makeASTRoot(currentAST, tmp200_AST); |
5655 | match(LAND); |
5656 | inclusiveOrExpression(); |
5657 | astFactory.addASTChild(currentAST, returnAST); |
5658 | } |
5659 | else { |
5660 | break _loop245; |
5661 | } |
5662 | |
5663 | } while (true); |
5664 | } |
5665 | logicalAndExpression_AST = (AST)currentAST.root; |
5666 | returnAST = logicalAndExpression_AST; |
5667 | } |
5668 | |
5669 | public final void inclusiveOrExpression() throws RecognitionException, TokenStreamException { |
5670 | |
5671 | returnAST = null; |
5672 | ASTPair currentAST = new ASTPair(); |
5673 | AST inclusiveOrExpression_AST = null; |
5674 | |
5675 | exclusiveOrExpression(); |
5676 | astFactory.addASTChild(currentAST, returnAST); |
5677 | { |
5678 | _loop248: |
5679 | do { |
5680 | if ((LA(1)==BOR)) { |
5681 | AST tmp201_AST = null; |
5682 | tmp201_AST = astFactory.create(LT(1)); |
5683 | astFactory.makeASTRoot(currentAST, tmp201_AST); |
5684 | match(BOR); |
5685 | exclusiveOrExpression(); |
5686 | astFactory.addASTChild(currentAST, returnAST); |
5687 | } |
5688 | else { |
5689 | break _loop248; |
5690 | } |
5691 | |
5692 | } while (true); |
5693 | } |
5694 | inclusiveOrExpression_AST = (AST)currentAST.root; |
5695 | returnAST = inclusiveOrExpression_AST; |
5696 | } |
5697 | |
5698 | public final void exclusiveOrExpression() throws RecognitionException, TokenStreamException { |
5699 | |
5700 | returnAST = null; |
5701 | ASTPair currentAST = new ASTPair(); |
5702 | AST exclusiveOrExpression_AST = null; |
5703 | |
5704 | andExpression(); |
5705 | astFactory.addASTChild(currentAST, returnAST); |
5706 | { |
5707 | _loop251: |
5708 | do { |
5709 | if ((LA(1)==BXOR)) { |
5710 | AST tmp202_AST = null; |
5711 | tmp202_AST = astFactory.create(LT(1)); |
5712 | astFactory.makeASTRoot(currentAST, tmp202_AST); |
5713 | match(BXOR); |
5714 | andExpression(); |
5715 | astFactory.addASTChild(currentAST, returnAST); |
5716 | } |
5717 | else { |
5718 | break _loop251; |
5719 | } |
5720 | |
5721 | } while (true); |
5722 | } |
5723 | exclusiveOrExpression_AST = (AST)currentAST.root; |
5724 | returnAST = exclusiveOrExpression_AST; |
5725 | } |
5726 | |
5727 | public final void andExpression() throws RecognitionException, TokenStreamException { |
5728 | |
5729 | returnAST = null; |
5730 | ASTPair currentAST = new ASTPair(); |
5731 | AST andExpression_AST = null; |
5732 | |
5733 | equalityExpression(); |
5734 | astFactory.addASTChild(currentAST, returnAST); |
5735 | { |
5736 | _loop254: |
5737 | do { |
5738 | if ((LA(1)==BAND)) { |
5739 | AST tmp203_AST = null; |
5740 | tmp203_AST = astFactory.create(LT(1)); |
5741 | astFactory.makeASTRoot(currentAST, tmp203_AST); |
5742 | match(BAND); |
5743 | equalityExpression(); |
5744 | astFactory.addASTChild(currentAST, returnAST); |
5745 | } |
5746 | else { |
5747 | break _loop254; |
5748 | } |
5749 | |
5750 | } while (true); |
5751 | } |
5752 | andExpression_AST = (AST)currentAST.root; |
5753 | returnAST = andExpression_AST; |
5754 | } |
5755 | |
5756 | public final void equalityExpression() throws RecognitionException, TokenStreamException { |
5757 | |
5758 | returnAST = null; |
5759 | ASTPair currentAST = new ASTPair(); |
5760 | AST equalityExpression_AST = null; |
5761 | |
5762 | relationalExpression(); |
5763 | astFactory.addASTChild(currentAST, returnAST); |
5764 | { |
5765 | _loop258: |
5766 | do { |
5767 | if ((LA(1)==NOT_EQUAL||LA(1)==EQUAL)) { |
5768 | { |
5769 | switch ( LA(1)) { |
5770 | case NOT_EQUAL: |
5771 | { |
5772 | AST tmp204_AST = null; |
5773 | tmp204_AST = astFactory.create(LT(1)); |
5774 | astFactory.makeASTRoot(currentAST, tmp204_AST); |
5775 | match(NOT_EQUAL); |
5776 | break; |
5777 | } |
5778 | case EQUAL: |
5779 | { |
5780 | AST tmp205_AST = null; |
5781 | tmp205_AST = astFactory.create(LT(1)); |
5782 | astFactory.makeASTRoot(currentAST, tmp205_AST); |
5783 | match(EQUAL); |
5784 | break; |
5785 | } |
5786 | default: |
5787 | { |
5788 | throw new NoViableAltException(LT(1), getFilename()); |
5789 | } |
5790 | } |
5791 | } |
5792 | relationalExpression(); |
5793 | astFactory.addASTChild(currentAST, returnAST); |
5794 | } |
5795 | else { |
5796 | break _loop258; |
5797 | } |
5798 | |
5799 | } while (true); |
5800 | } |
5801 | equalityExpression_AST = (AST)currentAST.root; |
5802 | returnAST = equalityExpression_AST; |
5803 | } |
5804 | |
5805 | public final void relationalExpression() throws RecognitionException, TokenStreamException { |
5806 | |
5807 | returnAST = null; |
5808 | ASTPair currentAST = new ASTPair(); |
5809 | AST relationalExpression_AST = null; |
5810 | |
5811 | shiftExpression(); |
5812 | astFactory.addASTChild(currentAST, returnAST); |
5813 | { |
5814 | switch ( LA(1)) { |
5815 | case SEMI: |
5816 | case RBRACK: |
5817 | case QUESTION: |
5818 | case LT: |
5819 | case COMMA: |
5820 | case GT: |
5821 | case RPAREN: |
5822 | case ASSIGN: |
5823 | case RCURLY: |
5824 | case BAND: |
5825 | case COLON: |
5826 | case PLUS_ASSIGN: |
5827 | case MINUS_ASSIGN: |
5828 | case STAR_ASSIGN: |
5829 | case DIV_ASSIGN: |
5830 | case MOD_ASSIGN: |
5831 | case SR_ASSIGN: |
5832 | case BSR_ASSIGN: |
5833 | case SL_ASSIGN: |
5834 | case BAND_ASSIGN: |
5835 | case BXOR_ASSIGN: |
5836 | case BOR_ASSIGN: |
5837 | case LOR: |
5838 | case LAND: |
5839 | case BOR: |
5840 | case BXOR: |
5841 | case NOT_EQUAL: |
5842 | case EQUAL: |
5843 | case LE: |
5844 | case GE: |
5845 | { |
5846 | { |
5847 | _loop263: |
5848 | do { |
5849 | if ((_tokenSet_39.member(LA(1)))) { |
5850 | { |
5851 | switch ( LA(1)) { |
5852 | case LT: |
5853 | { |
5854 | AST tmp206_AST = null; |
5855 | tmp206_AST = astFactory.create(LT(1)); |
5856 | astFactory.makeASTRoot(currentAST, tmp206_AST); |
5857 | match(LT); |
5858 | break; |
5859 | } |
5860 | case GT: |
5861 | { |
5862 | AST tmp207_AST = null; |
5863 | tmp207_AST = astFactory.create(LT(1)); |
5864 | astFactory.makeASTRoot(currentAST, tmp207_AST); |
5865 | match(GT); |
5866 | break; |
5867 | } |
5868 | case LE: |
5869 | { |
5870 | AST tmp208_AST = null; |
5871 | tmp208_AST = astFactory.create(LT(1)); |
5872 | astFactory.makeASTRoot(currentAST, tmp208_AST); |
5873 | match(LE); |
5874 | break; |
5875 | } |
5876 | case GE: |
5877 | { |
5878 | AST tmp209_AST = null; |
5879 | tmp209_AST = astFactory.create(LT(1)); |
5880 | astFactory.makeASTRoot(currentAST, tmp209_AST); |
5881 | match(GE); |
5882 | break; |
5883 | } |
5884 | default: |
5885 | { |
5886 | throw new NoViableAltException(LT(1), getFilename()); |
5887 | } |
5888 | } |
5889 | } |
5890 | shiftExpression(); |
5891 | astFactory.addASTChild(currentAST, returnAST); |
5892 | } |
5893 | else { |
5894 | break _loop263; |
5895 | } |
5896 | |
5897 | } while (true); |
5898 | } |
5899 | break; |
5900 | } |
5901 | case LITERAL_instanceof: |
5902 | { |
5903 | AST tmp210_AST = null; |
5904 | tmp210_AST = astFactory.create(LT(1)); |
5905 | astFactory.makeASTRoot(currentAST, tmp210_AST); |
5906 | match(LITERAL_instanceof); |
5907 | typeSpec(true); |
5908 | astFactory.addASTChild(currentAST, returnAST); |
5909 | break; |
5910 | } |
5911 | default: |
5912 | { |
5913 | throw new NoViableAltException(LT(1), getFilename()); |
5914 | } |
5915 | } |
5916 | } |
5917 | relationalExpression_AST = (AST)currentAST.root; |
5918 | returnAST = relationalExpression_AST; |
5919 | } |
5920 | |
5921 | public final void shiftExpression() throws RecognitionException, TokenStreamException { |
5922 | |
5923 | returnAST = null; |
5924 | ASTPair currentAST = new ASTPair(); |
5925 | AST shiftExpression_AST = null; |
5926 | |
5927 | additiveExpression(); |
5928 | astFactory.addASTChild(currentAST, returnAST); |
5929 | { |
5930 | _loop267: |
5931 | do { |
5932 | if ((_tokenSet_40.member(LA(1)))) { |
5933 | { |
5934 | switch ( LA(1)) { |
5935 | case SL: |
5936 | { |
5937 | AST tmp211_AST = null; |
5938 | tmp211_AST = astFactory.create(LT(1)); |
5939 | astFactory.makeASTRoot(currentAST, tmp211_AST); |
5940 | match(SL); |
5941 | break; |
5942 | } |
5943 | case SR: |
5944 | { |
5945 | AST tmp212_AST = null; |
5946 | tmp212_AST = astFactory.create(LT(1)); |
5947 | astFactory.makeASTRoot(currentAST, tmp212_AST); |
5948 | match(SR); |
5949 | break; |
5950 | } |
5951 | case BSR: |
5952 | { |
5953 | AST tmp213_AST = null; |
5954 | tmp213_AST = astFactory.create(LT(1)); |
5955 | astFactory.makeASTRoot(currentAST, tmp213_AST); |
5956 | match(BSR); |
5957 | break; |
5958 | } |
5959 | default: |
5960 | { |
5961 | throw new NoViableAltException(LT(1), getFilename()); |
5962 | } |
5963 | } |
5964 | } |
5965 | additiveExpression(); |
5966 | astFactory.addASTChild(currentAST, returnAST); |
5967 | } |
5968 | else { |
5969 | break _loop267; |
5970 | } |
5971 | |
5972 | } while (true); |
5973 | } |
5974 | shiftExpression_AST = (AST)currentAST.root; |
5975 | returnAST = shiftExpression_AST; |
5976 | } |
5977 | |
5978 | public final void additiveExpression() throws RecognitionException, TokenStreamException { |
5979 | |
5980 | returnAST = null; |
5981 | ASTPair currentAST = new ASTPair(); |
5982 | AST additiveExpression_AST = null; |
5983 | |
5984 | multiplicativeExpression(); |
5985 | astFactory.addASTChild(currentAST, returnAST); |
5986 | { |
5987 | _loop271: |
5988 | do { |
5989 | if ((LA(1)==PLUS||LA(1)==MINUS)) { |
5990 | { |
5991 | switch ( LA(1)) { |
5992 | case PLUS: |
5993 | { |
5994 | AST tmp214_AST = null; |
5995 | tmp214_AST = astFactory.create(LT(1)); |
5996 | astFactory.makeASTRoot(currentAST, tmp214_AST); |
5997 | match(PLUS); |
5998 | break; |
5999 | } |
6000 | case MINUS: |
6001 | { |
6002 | AST tmp215_AST = null; |
6003 | tmp215_AST = astFactory.create(LT(1)); |
6004 | astFactory.makeASTRoot(currentAST, tmp215_AST); |
6005 | match(MINUS); |
6006 | break; |
6007 | } |
6008 | default: |
6009 | { |
6010 | throw new NoViableAltException(LT(1), getFilename()); |
6011 | } |
6012 | } |
6013 | } |
6014 | multiplicativeExpression(); |
6015 | astFactory.addASTChild(currentAST, returnAST); |
6016 | } |
6017 | else { |
6018 | break _loop271; |
6019 | } |
6020 | |
6021 | } while (true); |
6022 | } |
6023 | additiveExpression_AST = (AST)currentAST.root; |
6024 | returnAST = additiveExpression_AST; |
6025 | } |
6026 | |
6027 | public final void multiplicativeExpression() throws RecognitionException, TokenStreamException { |
6028 | |
6029 | returnAST = null; |
6030 | ASTPair currentAST = new ASTPair(); |
6031 | AST multiplicativeExpression_AST = null; |
6032 | |
6033 | unaryExpression(); |
6034 | astFactory.addASTChild(currentAST, returnAST); |
6035 | { |
6036 | _loop275: |
6037 | do { |
6038 | if ((_tokenSet_41.member(LA(1)))) { |
6039 | { |
6040 | switch ( LA(1)) { |
6041 | case STAR: |
6042 | { |
6043 | AST tmp216_AST = null; |
6044 | tmp216_AST = astFactory.create(LT(1)); |
6045 | astFactory.makeASTRoot(currentAST, tmp216_AST); |
6046 | match(STAR); |
6047 | break; |
6048 | } |
6049 | case DIV: |
6050 | { |
6051 | AST tmp217_AST = null; |
6052 | tmp217_AST = astFactory.create(LT(1)); |
6053 | astFactory.makeASTRoot(currentAST, tmp217_AST); |
6054 | match(DIV); |
6055 | break; |
6056 | } |
6057 | case MOD: |
6058 | { |
6059 | AST tmp218_AST = null; |
6060 | tmp218_AST = astFactory.create(LT(1)); |
6061 | astFactory.makeASTRoot(currentAST, tmp218_AST); |
6062 | match(MOD); |
6063 | break; |
6064 | } |
6065 | default: |
6066 | { |
6067 | throw new NoViableAltException(LT(1), getFilename()); |
6068 | } |
6069 | } |
6070 | } |
6071 | unaryExpression(); |
6072 | astFactory.addASTChild(currentAST, returnAST); |
6073 | } |
6074 | else { |
6075 | break _loop275; |
6076 | } |
6077 | |
6078 | } while (true); |
6079 | } |
6080 | multiplicativeExpression_AST = (AST)currentAST.root; |
6081 | returnAST = multiplicativeExpression_AST; |
6082 | } |
6083 | |
6084 | public final void unaryExpression() throws RecognitionException, TokenStreamException { |
6085 | |
6086 | returnAST = null; |
6087 | ASTPair currentAST = new ASTPair(); |
6088 | AST unaryExpression_AST = null; |
6089 | |
6090 | switch ( LA(1)) { |
6091 | case INC: |
6092 | { |
6093 | AST tmp219_AST = null; |
6094 | tmp219_AST = astFactory.create(LT(1)); |
6095 | astFactory.makeASTRoot(currentAST, tmp219_AST); |
6096 | match(INC); |
6097 | unaryExpression(); |
6098 | astFactory.addASTChild(currentAST, returnAST); |
6099 | unaryExpression_AST = (AST)currentAST.root; |
6100 | break; |
6101 | } |
6102 | case DEC: |
6103 | { |
6104 | AST tmp220_AST = null; |
6105 | tmp220_AST = astFactory.create(LT(1)); |
6106 | astFactory.makeASTRoot(currentAST, tmp220_AST); |
6107 | match(DEC); |
6108 | unaryExpression(); |
6109 | astFactory.addASTChild(currentAST, returnAST); |
6110 | unaryExpression_AST = (AST)currentAST.root; |
6111 | break; |
6112 | } |
6113 | case MINUS: |
6114 | { |
6115 | AST tmp221_AST = null; |
6116 | tmp221_AST = astFactory.create(LT(1)); |
6117 | astFactory.makeASTRoot(currentAST, tmp221_AST); |
6118 | match(MINUS); |
6119 | if ( inputState.guessing==0 ) { |
6120 | tmp221_AST.setType(UNARY_MINUS); |
6121 | } |
6122 | unaryExpression(); |
6123 | astFactory.addASTChild(currentAST, returnAST); |
6124 | unaryExpression_AST = (AST)currentAST.root; |
6125 | break; |
6126 | } |
6127 | case PLUS: |
6128 | { |
6129 | AST tmp222_AST = null; |
6130 | tmp222_AST = astFactory.create(LT(1)); |
6131 | astFactory.makeASTRoot(currentAST, tmp222_AST); |
6132 | match(PLUS); |
6133 | if ( inputState.guessing==0 ) { |
6134 | tmp222_AST.setType(UNARY_PLUS); |
6135 | } |
6136 | unaryExpression(); |
6137 | astFactory.addASTChild(currentAST, returnAST); |
6138 | unaryExpression_AST = (AST)currentAST.root; |
6139 | break; |
6140 | } |
6141 | case IDENT: |
6142 | case LITERAL_super: |
6143 | case LT: |
6144 | case LITERAL_void: |
6145 | case LITERAL_boolean: |
6146 | case LITERAL_byte: |
6147 | case LITERAL_char: |
6148 | case LITERAL_short: |
6149 | case LITERAL_int: |
6150 | case LITERAL_float: |
6151 | case LITERAL_long: |
6152 | case LITERAL_double: |
6153 | case LPAREN: |
6154 | case LITERAL_this: |
6155 | case BNOT: |
6156 | case LNOT: |
6157 | case LITERAL_true: |
6158 | case LITERAL_false: |
6159 | case LITERAL_null: |
6160 | case LITERAL_new: |
6161 | case NUM_INT: |
6162 | case CHAR_LITERAL: |
6163 | case STRING_LITERAL: |
6164 | case NUM_FLOAT: |
6165 | case NUM_LONG: |
6166 | case NUM_DOUBLE: |
6167 | { |
6168 | unaryExpressionNotPlusMinus(); |
6169 | astFactory.addASTChild(currentAST, returnAST); |
6170 | unaryExpression_AST = (AST)currentAST.root; |
6171 | break; |
6172 | } |
6173 | default: |
6174 | { |
6175 | throw new NoViableAltException(LT(1), getFilename()); |
6176 | } |
6177 | } |
6178 | returnAST = unaryExpression_AST; |
6179 | } |
6180 | |
6181 | public final void unaryExpressionNotPlusMinus() throws RecognitionException, TokenStreamException { |
6182 | |
6183 | returnAST = null; |
6184 | ASTPair currentAST = new ASTPair(); |
6185 | AST unaryExpressionNotPlusMinus_AST = null; |
6186 | Token lpb = null; |
6187 | AST lpb_AST = null; |
6188 | Token lp = null; |
6189 | AST lp_AST = null; |
6190 | |
6191 | switch ( LA(1)) { |
6192 | case BNOT: |
6193 | { |
6194 | AST tmp223_AST = null; |
6195 | tmp223_AST = astFactory.create(LT(1)); |
6196 | astFactory.makeASTRoot(currentAST, tmp223_AST); |
6197 | match(BNOT); |
6198 | unaryExpression(); |
6199 | astFactory.addASTChild(currentAST, returnAST); |
6200 | unaryExpressionNotPlusMinus_AST = (AST)currentAST.root; |
6201 | break; |
6202 | } |
6203 | case LNOT: |
6204 | { |
6205 | AST tmp224_AST = null; |
6206 | tmp224_AST = astFactory.create(LT(1)); |
6207 | astFactory.makeASTRoot(currentAST, tmp224_AST); |
6208 | match(LNOT); |
6209 | unaryExpression(); |
6210 | astFactory.addASTChild(currentAST, returnAST); |
6211 | unaryExpressionNotPlusMinus_AST = (AST)currentAST.root; |
6212 | break; |
6213 | } |
6214 | case IDENT: |
6215 | case LITERAL_super: |
6216 | case LT: |
6217 | case LITERAL_void: |
6218 | case LITERAL_boolean: |
6219 | case LITERAL_byte: |
6220 | case LITERAL_char: |
6221 | case LITERAL_short: |
6222 | case LITERAL_int: |
6223 | case LITERAL_float: |
6224 | case LITERAL_long: |
6225 | case LITERAL_double: |
6226 | case LPAREN: |
6227 | case LITERAL_this: |
6228 | case LITERAL_true: |
6229 | case LITERAL_false: |
6230 | case LITERAL_null: |
6231 | case LITERAL_new: |
6232 | case NUM_INT: |
6233 | case CHAR_LITERAL: |
6234 | case STRING_LITERAL: |
6235 | case NUM_FLOAT: |
6236 | case NUM_LONG: |
6237 | case NUM_DOUBLE: |
6238 | { |
6239 | { |
6240 | boolean synPredMatched280 = false; |
6241 | if (((LA(1)==LPAREN) && ((LA(2) >= LITERAL_void && LA(2) <= LITERAL_double)))) { |
6242 | int _m280 = mark(); |
6243 | synPredMatched280 = true; |
6244 | inputState.guessing++; |
6245 | try { |
6246 | { |
6247 | match(LPAREN); |
6248 | builtInTypeSpec(true); |
6249 | match(RPAREN); |
6250 | unaryExpression(); |
6251 | } |
6252 | } |
6253 | catch (RecognitionException pe) { |
6254 | synPredMatched280 = false; |
6255 | } |
6256 | rewind(_m280); |
6257 | inputState.guessing--; |
6258 | } |
6259 | if ( synPredMatched280 ) { |
6260 | lpb = LT(1); |
6261 | lpb_AST = astFactory.create(lpb); |
6262 | astFactory.makeASTRoot(currentAST, lpb_AST); |
6263 | match(LPAREN); |
6264 | if ( inputState.guessing==0 ) { |
6265 | lpb_AST.setType(TYPECAST); |
6266 | } |
6267 | builtInTypeSpec(true); |
6268 | astFactory.addASTChild(currentAST, returnAST); |
6269 | match(RPAREN); |
6270 | unaryExpression(); |
6271 | astFactory.addASTChild(currentAST, returnAST); |
6272 | } |
6273 | else { |
6274 | boolean synPredMatched282 = false; |
6275 | if (((LA(1)==LPAREN) && (LA(2)==IDENT))) { |
6276 | int _m282 = mark(); |
6277 | synPredMatched282 = true; |
6278 | inputState.guessing++; |
6279 | try { |
6280 | { |
6281 | match(LPAREN); |
6282 | classTypeSpec(true); |
6283 | match(RPAREN); |
6284 | unaryExpressionNotPlusMinus(); |
6285 | } |
6286 | } |
6287 | catch (RecognitionException pe) { |
6288 | synPredMatched282 = false; |
6289 | } |
6290 | rewind(_m282); |
6291 | inputState.guessing--; |
6292 | } |
6293 | if ( synPredMatched282 ) { |
6294 | lp = LT(1); |
6295 | lp_AST = astFactory.create(lp); |
6296 | astFactory.makeASTRoot(currentAST, lp_AST); |
6297 | match(LPAREN); |
6298 | if ( inputState.guessing==0 ) { |
6299 | lp_AST.setType(TYPECAST); |
6300 | } |
6301 | classTypeSpec(true); |
6302 | astFactory.addASTChild(currentAST, returnAST); |
6303 | match(RPAREN); |
6304 | unaryExpressionNotPlusMinus(); |
6305 | astFactory.addASTChild(currentAST, returnAST); |
6306 | } |
6307 | else if ((_tokenSet_42.member(LA(1))) && (_tokenSet_43.member(LA(2)))) { |
6308 | postfixExpression(); |
6309 | astFactory.addASTChild(currentAST, returnAST); |
6310 | } |
6311 | else { |
6312 | throw new NoViableAltException(LT(1), getFilename()); |
6313 | } |
6314 | } |
6315 | } |
6316 | unaryExpressionNotPlusMinus_AST = (AST)currentAST.root; |
6317 | break; |
6318 | } |
6319 | default: |
6320 | { |
6321 | throw new NoViableAltException(LT(1), getFilename()); |
6322 | } |
6323 | } |
6324 | returnAST = unaryExpressionNotPlusMinus_AST; |
6325 | } |
6326 | |
6327 | public final void postfixExpression() throws RecognitionException, TokenStreamException { |
6328 | |
6329 | returnAST = null; |
6330 | ASTPair currentAST = new ASTPair(); |
6331 | AST postfixExpression_AST = null; |
6332 | Token lp = null; |
6333 | AST lp_AST = null; |
6334 | Token lp3 = null; |
6335 | AST lp3_AST = null; |
6336 | Token lps = null; |
6337 | AST lps_AST = null; |
6338 | Token lb = null; |
6339 | AST lb_AST = null; |
6340 | Token in = null; |
6341 | AST in_AST = null; |
6342 | Token de = null; |
6343 | AST de_AST = null; |
6344 | |
6345 | primaryExpression(); |
6346 | astFactory.addASTChild(currentAST, returnAST); |
6347 | { |
6348 | _loop291: |
6349 | do { |
6350 | if ((LA(1)==DOT) && (_tokenSet_44.member(LA(2)))) { |
6351 | AST tmp227_AST = null; |
6352 | tmp227_AST = astFactory.create(LT(1)); |
6353 | astFactory.makeASTRoot(currentAST, tmp227_AST); |
6354 | match(DOT); |
6355 | { |
6356 | switch ( LA(1)) { |
6357 | case LT: |
6358 | { |
6359 | typeArguments(); |
6360 | astFactory.addASTChild(currentAST, returnAST); |
6361 | break; |
6362 | } |
6363 | case IDENT: |
6364 | case LITERAL_super: |
6365 | { |
6366 | break; |
6367 | } |
6368 | default: |
6369 | { |
6370 | throw new NoViableAltException(LT(1), getFilename()); |
6371 | } |
6372 | } |
6373 | } |
6374 | { |
6375 | switch ( LA(1)) { |
6376 | case IDENT: |
6377 | { |
6378 | AST tmp228_AST = null; |
6379 | tmp228_AST = astFactory.create(LT(1)); |
6380 | astFactory.addASTChild(currentAST, tmp228_AST); |
6381 | match(IDENT); |
6382 | { |
6383 | switch ( LA(1)) { |
6384 | case LPAREN: |
6385 | { |
6386 | lp = LT(1); |
6387 | lp_AST = astFactory.create(lp); |
6388 | astFactory.makeASTRoot(currentAST, lp_AST); |
6389 | match(LPAREN); |
6390 | if ( inputState.guessing==0 ) { |
6391 | lp_AST.setType(METHOD_CALL); |
6392 | } |
6393 | argList(); |
6394 | astFactory.addASTChild(currentAST, returnAST); |
6395 | match(RPAREN); |
6396 | break; |
6397 | } |
6398 | case SEMI: |
6399 | case LBRACK: |
6400 | case RBRACK: |
6401 | case DOT: |
6402 | case QUESTION: |
6403 | case LT: |
6404 | case COMMA: |
6405 | case GT: |
6406 | case SR: |
6407 | case BSR: |
6408 | case STAR: |
6409 | case RPAREN: |
6410 | case ASSIGN: |
6411 | case RCURLY: |
6412 | case BAND: |
6413 | case COLON: |
6414 | case PLUS_ASSIGN: |
6415 | case MINUS_ASSIGN: |
6416 | case STAR_ASSIGN: |
6417 | case DIV_ASSIGN: |
6418 | case MOD_ASSIGN: |
6419 | case SR_ASSIGN: |
6420 | case BSR_ASSIGN: |
6421 | case SL_ASSIGN: |
6422 | case BAND_ASSIGN: |
6423 | case BXOR_ASSIGN: |
6424 | case BOR_ASSIGN: |
6425 | case LOR: |
6426 | case LAND: |
6427 | case BOR: |
6428 | case BXOR: |
6429 | case NOT_EQUAL: |
6430 | case EQUAL: |
6431 | case LE: |
6432 | case GE: |
6433 | case LITERAL_instanceof: |
6434 | case SL: |
6435 | case PLUS: |
6436 | case MINUS: |
6437 | case DIV: |
6438 | case MOD: |
6439 | case INC: |
6440 | case DEC: |
6441 | { |
6442 | break; |
6443 | } |
6444 | default: |
6445 | { |
6446 | throw new NoViableAltException(LT(1), getFilename()); |
6447 | } |
6448 | } |
6449 | } |
6450 | break; |
6451 | } |
6452 | case LITERAL_super: |
6453 | { |
6454 | AST tmp230_AST = null; |
6455 | tmp230_AST = astFactory.create(LT(1)); |
6456 | astFactory.addASTChild(currentAST, tmp230_AST); |
6457 | match(LITERAL_super); |
6458 | { |
6459 | switch ( LA(1)) { |
6460 | case LPAREN: |
6461 | { |
6462 | lp3 = LT(1); |
6463 | lp3_AST = astFactory.create(lp3); |
6464 | astFactory.makeASTRoot(currentAST, lp3_AST); |
6465 | match(LPAREN); |
6466 | argList(); |
6467 | astFactory.addASTChild(currentAST, returnAST); |
6468 | match(RPAREN); |
6469 | if ( inputState.guessing==0 ) { |
6470 | lp3_AST.setType(SUPER_CTOR_CALL); |
6471 | } |
6472 | break; |
6473 | } |
6474 | case DOT: |
6475 | { |
6476 | AST tmp232_AST = null; |
6477 | tmp232_AST = astFactory.create(LT(1)); |
6478 | astFactory.makeASTRoot(currentAST, tmp232_AST); |
6479 | match(DOT); |
6480 | { |
6481 | switch ( LA(1)) { |
6482 | case LT: |
6483 | { |
6484 | typeArguments(); |
6485 | astFactory.addASTChild(currentAST, returnAST); |
6486 | break; |
6487 | } |
6488 | case IDENT: |
6489 | { |
6490 | break; |
6491 | } |
6492 | default: |
6493 | { |
6494 | throw new NoViableAltException(LT(1), getFilename()); |
6495 | } |
6496 | } |
6497 | } |
6498 | AST tmp233_AST = null; |
6499 | tmp233_AST = astFactory.create(LT(1)); |
6500 | astFactory.addASTChild(currentAST, tmp233_AST); |
6501 | match(IDENT); |
6502 | { |
6503 | switch ( LA(1)) { |
6504 | case LPAREN: |
6505 | { |
6506 | lps = LT(1); |
6507 | lps_AST = astFactory.create(lps); |
6508 | astFactory.makeASTRoot(currentAST, lps_AST); |
6509 | match(LPAREN); |
6510 | if ( inputState.guessing==0 ) { |
6511 | lps_AST.setType(METHOD_CALL); |
6512 | } |
6513 | argList(); |
6514 | astFactory.addASTChild(currentAST, returnAST); |
6515 | match(RPAREN); |
6516 | break; |
6517 | } |
6518 | case SEMI: |
6519 | case LBRACK: |
6520 | case RBRACK: |
6521 | case DOT: |
6522 | case QUESTION: |
6523 | case LT: |
6524 | case COMMA: |
6525 | case GT: |
6526 | case SR: |
6527 | case BSR: |
6528 | case STAR: |
6529 | case RPAREN: |
6530 | case ASSIGN: |
6531 | case RCURLY: |
6532 | case BAND: |
6533 | case COLON: |
6534 | case PLUS_ASSIGN: |
6535 | case MINUS_ASSIGN: |
6536 | case STAR_ASSIGN: |
6537 | case DIV_ASSIGN: |
6538 | case MOD_ASSIGN: |
6539 | case SR_ASSIGN: |
6540 | case BSR_ASSIGN: |
6541 | case SL_ASSIGN: |
6542 | case BAND_ASSIGN: |
6543 | case BXOR_ASSIGN: |
6544 | case BOR_ASSIGN: |
6545 | case LOR: |
6546 | case LAND: |
6547 | case BOR: |
6548 | case BXOR: |
6549 | case NOT_EQUAL: |
6550 | case EQUAL: |
6551 | case LE: |
6552 | case GE: |
6553 | case LITERAL_instanceof: |
6554 | case SL: |
6555 | case PLUS: |
6556 | case MINUS: |
6557 | case DIV: |
6558 | case MOD: |
6559 | case INC: |
6560 | case DEC: |
6561 | { |
6562 | break; |
6563 | } |
6564 | default: |
6565 | { |
6566 | throw new NoViableAltException(LT(1), getFilename()); |
6567 | } |
6568 | } |
6569 | } |
6570 | break; |
6571 | } |
6572 | default: |
6573 | { |
6574 | throw new NoViableAltException(LT(1), getFilename()); |
6575 | } |
6576 | } |
6577 | } |
6578 | break; |
6579 | } |
6580 | default: |
6581 | { |
6582 | throw new NoViableAltException(LT(1), getFilename()); |
6583 | } |
6584 | } |
6585 | } |
6586 | } |
6587 | else if ((LA(1)==DOT) && (LA(2)==LITERAL_this)) { |
6588 | AST tmp235_AST = null; |
6589 | tmp235_AST = astFactory.create(LT(1)); |
6590 | astFactory.makeASTRoot(currentAST, tmp235_AST); |
6591 | match(DOT); |
6592 | AST tmp236_AST = null; |
6593 | tmp236_AST = astFactory.create(LT(1)); |
6594 | astFactory.addASTChild(currentAST, tmp236_AST); |
6595 | match(LITERAL_this); |
6596 | } |
6597 | else if ((LA(1)==DOT) && (LA(2)==LITERAL_new)) { |
6598 | AST tmp237_AST = null; |
6599 | tmp237_AST = astFactory.create(LT(1)); |
6600 | astFactory.makeASTRoot(currentAST, tmp237_AST); |
6601 | match(DOT); |
6602 | newExpression(); |
6603 | astFactory.addASTChild(currentAST, returnAST); |
6604 | } |
6605 | else if ((LA(1)==LBRACK)) { |
6606 | lb = LT(1); |
6607 | lb_AST = astFactory.create(lb); |
6608 | astFactory.makeASTRoot(currentAST, lb_AST); |
6609 | match(LBRACK); |
6610 | if ( inputState.guessing==0 ) { |
6611 | lb_AST.setType(INDEX_OP); |
6612 | } |
6613 | expression(); |
6614 | astFactory.addASTChild(currentAST, returnAST); |
6615 | match(RBRACK); |
6616 | } |
6617 | else { |
6618 | break _loop291; |
6619 | } |
6620 | |
6621 | } while (true); |
6622 | } |
6623 | { |
6624 | switch ( LA(1)) { |
6625 | case INC: |
6626 | { |
6627 | in = LT(1); |
6628 | in_AST = astFactory.create(in); |
6629 | astFactory.makeASTRoot(currentAST, in_AST); |
6630 | match(INC); |
6631 | if ( inputState.guessing==0 ) { |
6632 | in_AST.setType(POST_INC); |
6633 | } |
6634 | break; |
6635 | } |
6636 | case DEC: |
6637 | { |
6638 | de = LT(1); |
6639 | de_AST = astFactory.create(de); |
6640 | astFactory.makeASTRoot(currentAST, de_AST); |
6641 | match(DEC); |
6642 | if ( inputState.guessing==0 ) { |
6643 | de_AST.setType(POST_DEC); |
6644 | } |
6645 | break; |
6646 | } |
6647 | case SEMI: |
6648 | case RBRACK: |
6649 | case QUESTION: |
6650 | case LT: |
6651 | case COMMA: |
6652 | case GT: |
6653 | case SR: |
6654 | case BSR: |
6655 | case STAR: |
6656 | case RPAREN: |
6657 | case ASSIGN: |
6658 | case RCURLY: |
6659 | case BAND: |
6660 | case COLON: |
6661 | case PLUS_ASSIGN: |
6662 | case MINUS_ASSIGN: |
6663 | case STAR_ASSIGN: |
6664 | case DIV_ASSIGN: |
6665 | case MOD_ASSIGN: |
6666 | case SR_ASSIGN: |
6667 | case BSR_ASSIGN: |
6668 | case SL_ASSIGN: |
6669 | case BAND_ASSIGN: |
6670 | case BXOR_ASSIGN: |
6671 | case BOR_ASSIGN: |
6672 | case LOR: |
6673 | case LAND: |
6674 | case BOR: |
6675 | case BXOR: |
6676 | case NOT_EQUAL: |
6677 | case EQUAL: |
6678 | case LE: |
6679 | case GE: |
6680 | case LITERAL_instanceof: |
6681 | case SL: |
6682 | case PLUS: |
6683 | case MINUS: |
6684 | case DIV: |
6685 | case MOD: |
6686 | { |
6687 | break; |
6688 | } |
6689 | default: |
6690 | { |
6691 | throw new NoViableAltException(LT(1), getFilename()); |
6692 | } |
6693 | } |
6694 | } |
6695 | postfixExpression_AST = (AST)currentAST.root; |
6696 | returnAST = postfixExpression_AST; |
6697 | } |
6698 | |
6699 | public final void primaryExpression() throws RecognitionException, TokenStreamException { |
6700 | |
6701 | returnAST = null; |
6702 | ASTPair currentAST = new ASTPair(); |
6703 | AST primaryExpression_AST = null; |
6704 | Token lbt = null; |
6705 | AST lbt_AST = null; |
6706 | |
6707 | switch ( LA(1)) { |
6708 | case IDENT: |
6709 | case LT: |
6710 | { |
6711 | identPrimary(); |
6712 | astFactory.addASTChild(currentAST, returnAST); |
6713 | { |
6714 | if ((LA(1)==DOT) && (LA(2)==LITERAL_class)) { |
6715 | AST tmp239_AST = null; |
6716 | tmp239_AST = astFactory.create(LT(1)); |
6717 | astFactory.makeASTRoot(currentAST, tmp239_AST); |
6718 | match(DOT); |
6719 | AST tmp240_AST = null; |
6720 | tmp240_AST = astFactory.create(LT(1)); |
6721 | astFactory.addASTChild(currentAST, tmp240_AST); |
6722 | match(LITERAL_class); |
6723 | } |
6724 | else if ((_tokenSet_45.member(LA(1))) && (_tokenSet_46.member(LA(2)))) { |
6725 | } |
6726 | else { |
6727 | throw new NoViableAltException(LT(1), getFilename()); |
6728 | } |
6729 | |
6730 | } |
6731 | primaryExpression_AST = (AST)currentAST.root; |
6732 | break; |
6733 | } |
6734 | case NUM_INT: |
6735 | case CHAR_LITERAL: |
6736 | case STRING_LITERAL: |
6737 | case NUM_FLOAT: |
6738 | case NUM_LONG: |
6739 | case NUM_DOUBLE: |
6740 | { |
6741 | constant(); |
6742 | astFactory.addASTChild(currentAST, returnAST); |
6743 | primaryExpression_AST = (AST)currentAST.root; |
6744 | break; |
6745 | } |
6746 | case LITERAL_true: |
6747 | { |
6748 | AST tmp241_AST = null; |
6749 | tmp241_AST = astFactory.create(LT(1)); |
6750 | astFactory.addASTChild(currentAST, tmp241_AST); |
6751 | match(LITERAL_true); |
6752 | primaryExpression_AST = (AST)currentAST.root; |
6753 | break; |
6754 | } |
6755 | case LITERAL_false: |
6756 | { |
6757 | AST tmp242_AST = null; |
6758 | tmp242_AST = astFactory.create(LT(1)); |
6759 | astFactory.addASTChild(currentAST, tmp242_AST); |
6760 | match(LITERAL_false); |
6761 | primaryExpression_AST = (AST)currentAST.root; |
6762 | break; |
6763 | } |
6764 | case LITERAL_null: |
6765 | { |
6766 | AST tmp243_AST = null; |
6767 | tmp243_AST = astFactory.create(LT(1)); |
6768 | astFactory.addASTChild(currentAST, tmp243_AST); |
6769 | match(LITERAL_null); |
6770 | primaryExpression_AST = (AST)currentAST.root; |
6771 | break; |
6772 | } |
6773 | case LITERAL_new: |
6774 | { |
6775 | newExpression(); |
6776 | astFactory.addASTChild(currentAST, returnAST); |
6777 | primaryExpression_AST = (AST)currentAST.root; |
6778 | break; |
6779 | } |
6780 | case LITERAL_this: |
6781 | { |
6782 | AST tmp244_AST = null; |
6783 | tmp244_AST = astFactory.create(LT(1)); |
6784 | astFactory.addASTChild(currentAST, tmp244_AST); |
6785 | match(LITERAL_this); |
6786 | primaryExpression_AST = (AST)currentAST.root; |
6787 | break; |
6788 | } |
6789 | case LITERAL_super: |
6790 | { |
6791 | AST tmp245_AST = null; |
6792 | tmp245_AST = astFactory.create(LT(1)); |
6793 | astFactory.addASTChild(currentAST, tmp245_AST); |
6794 | match(LITERAL_super); |
6795 | primaryExpression_AST = (AST)currentAST.root; |
6796 | break; |
6797 | } |
6798 | case LPAREN: |
6799 | { |
6800 | match(LPAREN); |
6801 | assignmentExpression(); |
6802 | astFactory.addASTChild(currentAST, returnAST); |
6803 | match(RPAREN); |
6804 | primaryExpression_AST = (AST)currentAST.root; |
6805 | break; |
6806 | } |
6807 | case LITERAL_void: |
6808 | case LITERAL_boolean: |
6809 | case LITERAL_byte: |
6810 | case LITERAL_char: |
6811 | case LITERAL_short: |
6812 | case LITERAL_int: |
6813 | case LITERAL_float: |
6814 | case LITERAL_long: |
6815 | case LITERAL_double: |
6816 | { |
6817 | builtInType(); |
6818 | astFactory.addASTChild(currentAST, returnAST); |
6819 | { |
6820 | _loop296: |
6821 | do { |
6822 | if ((LA(1)==LBRACK)) { |
6823 | lbt = LT(1); |
6824 | lbt_AST = astFactory.create(lbt); |
6825 | astFactory.makeASTRoot(currentAST, lbt_AST); |
6826 | match(LBRACK); |
6827 | if ( inputState.guessing==0 ) { |
6828 | lbt_AST.setType(ARRAY_DECLARATOR); |
6829 | } |
6830 | match(RBRACK); |
6831 | } |
6832 | else { |
6833 | break _loop296; |
6834 | } |
6835 | |
6836 | } while (true); |
6837 | } |
6838 | AST tmp249_AST = null; |
6839 | tmp249_AST = astFactory.create(LT(1)); |
6840 | astFactory.makeASTRoot(currentAST, tmp249_AST); |
6841 | match(DOT); |
6842 | AST tmp250_AST = null; |
6843 | tmp250_AST = astFactory.create(LT(1)); |
6844 | astFactory.addASTChild(currentAST, tmp250_AST); |
6845 | match(LITERAL_class); |
6846 | primaryExpression_AST = (AST)currentAST.root; |
6847 | break; |
6848 | } |
6849 | default: |
6850 | { |
6851 | throw new NoViableAltException(LT(1), getFilename()); |
6852 | } |
6853 | } |
6854 | returnAST = primaryExpression_AST; |
6855 | } |
6856 | |
6857 | /** object instantiation. |
6858 | * Trees are built as illustrated by the following input/tree pairs: |
6859 | * |
6860 | * new T() |
6861 | * |
6862 | * new |
6863 | * | |
6864 | * T -- ELIST |
6865 | * | |
6866 | * arg1 -- arg2 -- .. -- argn |
6867 | * |
6868 | * new int[] |
6869 | * |
6870 | * new |
6871 | * | |
6872 | * int -- ARRAY_DECLARATOR |
6873 | * |
6874 | * new int[] {1,2} |
6875 | * |
6876 | * new |
6877 | * | |
6878 | * int -- ARRAY_DECLARATOR -- ARRAY_INIT |
6879 | * | |
6880 | * EXPR -- EXPR |
6881 | * | | |
6882 | * 1 2 |
6883 | * |
6884 | * new int[3] |
6885 | * new |
6886 | * | |
6887 | * int -- ARRAY_DECLARATOR |
6888 | * | |
6889 | * EXPR |
6890 | * | |
6891 | * 3 |
6892 | * |
6893 | * new int[1][2] |
6894 | * |
6895 | * new |
6896 | * | |
6897 | * int -- ARRAY_DECLARATOR |
6898 | * | |
6899 | * ARRAY_DECLARATOR -- EXPR |
6900 | * | | |
6901 | * EXPR 1 |
6902 | * | |
6903 | * 2 |
6904 | * |
6905 | */ |
6906 | public final void newExpression() throws RecognitionException, TokenStreamException { |
6907 | |
6908 | returnAST = null; |
6909 | ASTPair currentAST = new ASTPair(); |
6910 | AST newExpression_AST = null; |
6911 | |
6912 | AST tmp251_AST = null; |
6913 | tmp251_AST = astFactory.create(LT(1)); |
6914 | astFactory.makeASTRoot(currentAST, tmp251_AST); |
6915 | match(LITERAL_new); |
6916 | { |
6917 | switch ( LA(1)) { |
6918 | case LT: |
6919 | { |
6920 | typeArguments(); |
6921 | astFactory.addASTChild(currentAST, returnAST); |
6922 | break; |
6923 | } |
6924 | case IDENT: |
6925 | case LITERAL_void: |
6926 | case LITERAL_boolean: |
6927 | case LITERAL_byte: |
6928 | case LITERAL_char: |
6929 | case LITERAL_short: |
6930 | case LITERAL_int: |
6931 | case LITERAL_float: |
6932 | case LITERAL_long: |
6933 | case LITERAL_double: |
6934 | { |
6935 | break; |
6936 | } |
6937 | default: |
6938 | { |
6939 | throw new NoViableAltException(LT(1), getFilename()); |
6940 | } |
6941 | } |
6942 | } |
6943 | type(); |
6944 | astFactory.addASTChild(currentAST, returnAST); |
6945 | { |
6946 | switch ( LA(1)) { |
6947 | case LPAREN: |
6948 | { |
6949 | match(LPAREN); |
6950 | argList(); |
6951 | astFactory.addASTChild(currentAST, returnAST); |
6952 | match(RPAREN); |
6953 | { |
6954 | switch ( LA(1)) { |
6955 | case LCURLY: |
6956 | { |
6957 | classBlock(); |
6958 | astFactory.addASTChild(currentAST, returnAST); |
6959 | break; |
6960 | } |
6961 | case SEMI: |
6962 | case LBRACK: |
6963 | case RBRACK: |
6964 | case DOT: |
6965 | case QUESTION: |
6966 | case LT: |
6967 | case COMMA: |
6968 | case GT: |
6969 | case SR: |
6970 | case BSR: |
6971 | case STAR: |
6972 | case RPAREN: |
6973 | case ASSIGN: |
6974 | case RCURLY: |
6975 | case BAND: |
6976 | case COLON: |
6977 | case PLUS_ASSIGN: |
6978 | case MINUS_ASSIGN: |
6979 | case STAR_ASSIGN: |
6980 | case DIV_ASSIGN: |
6981 | case MOD_ASSIGN: |
6982 | case SR_ASSIGN: |
6983 | case BSR_ASSIGN: |
6984 | case SL_ASSIGN: |
6985 | case BAND_ASSIGN: |
6986 | case BXOR_ASSIGN: |
6987 | case BOR_ASSIGN: |
6988 | case LOR: |
6989 | case LAND: |
6990 | case BOR: |
6991 | case BXOR: |
6992 | case NOT_EQUAL: |
6993 | case EQUAL: |
6994 | case LE: |
6995 | case GE: |
6996 | case LITERAL_instanceof: |
6997 | case SL: |
6998 | case PLUS: |
6999 | case MINUS: |
7000 | case DIV: |
7001 | case MOD: |
7002 | case INC: |
7003 | case DEC: |
7004 | { |
7005 | break; |
7006 | } |
7007 | default: |
7008 | { |
7009 | throw new NoViableAltException(LT(1), getFilename()); |
7010 | } |
7011 | } |
7012 | } |
7013 | break; |
7014 | } |
7015 | case LBRACK: |
7016 | { |
7017 | newArrayDeclarator(); |
7018 | astFactory.addASTChild(currentAST, returnAST); |
7019 | { |
7020 | switch ( LA(1)) { |
7021 | case LCURLY: |
7022 | { |
7023 | arrayInitializer(); |
7024 | astFactory.addASTChild(currentAST, returnAST); |
7025 | break; |
7026 | } |
7027 | case SEMI: |
7028 | case LBRACK: |
7029 | case RBRACK: |
7030 | case DOT: |
7031 | case QUESTION: |
7032 | case LT: |
7033 | case COMMA: |
7034 | case GT: |
7035 | case SR: |
7036 | case BSR: |
7037 | case STAR: |
7038 | case RPAREN: |
7039 | case ASSIGN: |
7040 | case RCURLY: |
7041 | case BAND: |
7042 | case COLON: |
7043 | case PLUS_ASSIGN: |
7044 | case MINUS_ASSIGN: |
7045 | case STAR_ASSIGN: |
7046 | case DIV_ASSIGN: |
7047 | case MOD_ASSIGN: |
7048 | case SR_ASSIGN: |
7049 | case BSR_ASSIGN: |
7050 | case SL_ASSIGN: |
7051 | case BAND_ASSIGN: |
7052 | case BXOR_ASSIGN: |
7053 | case BOR_ASSIGN: |
7054 | case LOR: |
7055 | case LAND: |
7056 | case BOR: |
7057 | case BXOR: |
7058 | case NOT_EQUAL: |
7059 | case EQUAL: |
7060 | case LE: |
7061 | case GE: |
7062 | case LITERAL_instanceof: |
7063 | case SL: |
7064 | case PLUS: |
7065 | case MINUS: |
7066 | case DIV: |
7067 | case MOD: |
7068 | case INC: |
7069 | case DEC: |
7070 | { |
7071 | break; |
7072 | } |
7073 | default: |
7074 | { |
7075 | throw new NoViableAltException(LT(1), getFilename()); |
7076 | } |
7077 | } |
7078 | } |
7079 | break; |
7080 | } |
7081 | default: |
7082 | { |
7083 | throw new NoViableAltException(LT(1), getFilename()); |
7084 | } |
7085 | } |
7086 | } |
7087 | newExpression_AST = (AST)currentAST.root; |
7088 | returnAST = newExpression_AST; |
7089 | } |
7090 | |
7091 | /** Match a, a.b.c refs, a.b.c(...) refs, a.b.c[], a.b.c[].class, |
7092 | * and a.b.c.class refs. Also this(...) and super(...). Match |
7093 | * this or super. |
7094 | */ |
7095 | public final void identPrimary() throws RecognitionException, TokenStreamException { |
7096 | |
7097 | returnAST = null; |
7098 | ASTPair currentAST = new ASTPair(); |
7099 | AST identPrimary_AST = null; |
7100 | AST ta1_AST = null; |
7101 | AST ta2_AST = null; |
7102 | Token lp = null; |
7103 | AST lp_AST = null; |
7104 | Token lbc = null; |
7105 | AST lbc_AST = null; |
7106 | |
7107 | { |
7108 | switch ( LA(1)) { |
7109 | case LT: |
7110 | { |
7111 | typeArguments(); |
7112 | ta1_AST = (AST)returnAST; |
7113 | break; |
7114 | } |
7115 | case IDENT: |
7116 | { |
7117 | break; |
7118 | } |
7119 | default: |
7120 | { |
7121 | throw new NoViableAltException(LT(1), getFilename()); |
7122 | } |
7123 | } |
7124 | } |
7125 | AST tmp254_AST = null; |
7126 | tmp254_AST = astFactory.create(LT(1)); |
7127 | astFactory.addASTChild(currentAST, tmp254_AST); |
7128 | match(IDENT); |
7129 | { |
7130 | _loop304: |
7131 | do { |
7132 | boolean synPredMatched302 = false; |
7133 | if (((LA(1)==DOT) && (LA(2)==IDENT||LA(2)==LT))) { |
7134 | int _m302 = mark(); |
7135 | synPredMatched302 = true; |
7136 | inputState.guessing++; |
7137 | try { |
7138 | { |
7139 | match(DOT); |
7140 | { |
7141 | switch ( LA(1)) { |
7142 | case LT: |
7143 | { |
7144 | typeArguments(); |
7145 | break; |
7146 | } |
7147 | case IDENT: |
7148 | { |
7149 | break; |
7150 | } |
7151 | default: |
7152 | { |
7153 | throw new NoViableAltException(LT(1), getFilename()); |
7154 | } |
7155 | } |
7156 | } |
7157 | match(IDENT); |
7158 | } |
7159 | } |
7160 | catch (RecognitionException pe) { |
7161 | synPredMatched302 = false; |
7162 | } |
7163 | rewind(_m302); |
7164 | inputState.guessing--; |
7165 | } |
7166 | if ( synPredMatched302 ) { |
7167 | AST tmp255_AST = null; |
7168 | tmp255_AST = astFactory.create(LT(1)); |
7169 | astFactory.makeASTRoot(currentAST, tmp255_AST); |
7170 | match(DOT); |
7171 | { |
7172 | switch ( LA(1)) { |
7173 | case LT: |
7174 | { |
7175 | typeArguments(); |
7176 | ta2_AST = (AST)returnAST; |
7177 | break; |
7178 | } |
7179 | case IDENT: |
7180 | { |
7181 | break; |
7182 | } |
7183 | default: |
7184 | { |
7185 | throw new NoViableAltException(LT(1), getFilename()); |
7186 | } |
7187 | } |
7188 | } |
7189 | AST tmp256_AST = null; |
7190 | tmp256_AST = astFactory.create(LT(1)); |
7191 | astFactory.addASTChild(currentAST, tmp256_AST); |
7192 | match(IDENT); |
7193 | } |
7194 | else if (((_tokenSet_47.member(LA(1))) && (_tokenSet_46.member(LA(2))))&&(false)) { |
7195 | } |
7196 | else { |
7197 | break _loop304; |
7198 | } |
7199 | |
7200 | } while (true); |
7201 | } |
7202 | { |
7203 | if ((LA(1)==LPAREN)) { |
7204 | { |
7205 | lp = LT(1); |
7206 | lp_AST = astFactory.create(lp); |
7207 | astFactory.makeASTRoot(currentAST, lp_AST); |
7208 | match(LPAREN); |
7209 | if ( inputState.guessing==0 ) { |
7210 | lp_AST.setType(METHOD_CALL); |
7211 | } |
7212 | if ( inputState.guessing==0 ) { |
7213 | if (ta2_AST != null) astFactory.addASTChild(currentAST, ta2_AST); |
7214 | } |
7215 | if ( inputState.guessing==0 ) { |
7216 | if (ta2_AST == null) astFactory.addASTChild(currentAST, ta1_AST); |
7217 | } |
7218 | argList(); |
7219 | astFactory.addASTChild(currentAST, returnAST); |
7220 | match(RPAREN); |
7221 | } |
7222 | } |
7223 | else if ((LA(1)==LBRACK) && (LA(2)==RBRACK)) { |
7224 | { |
7225 | int _cnt308=0; |
7226 | _loop308: |
7227 | do { |
7228 | if ((LA(1)==LBRACK) && (LA(2)==RBRACK)) { |
7229 | lbc = LT(1); |
7230 | lbc_AST = astFactory.create(lbc); |
7231 | astFactory.makeASTRoot(currentAST, lbc_AST); |
7232 | match(LBRACK); |
7233 | if ( inputState.guessing==0 ) { |
7234 | lbc_AST.setType(ARRAY_DECLARATOR); |
7235 | } |
7236 | match(RBRACK); |
7237 | } |
7238 | else { |
7239 | if ( _cnt308>=1 ) { break _loop308; } else {throw new NoViableAltException(LT(1), getFilename());} |
7240 | } |
7241 | |
7242 | _cnt308++; |
7243 | } while (true); |
7244 | } |
7245 | } |
7246 | else if ((_tokenSet_45.member(LA(1))) && (_tokenSet_46.member(LA(2)))) { |
7247 | } |
7248 | else { |
7249 | throw new NoViableAltException(LT(1), getFilename()); |
7250 | } |
7251 | |
7252 | } |
7253 | identPrimary_AST = (AST)currentAST.root; |
7254 | returnAST = identPrimary_AST; |
7255 | } |
7256 | |
7257 | public final void constant() throws RecognitionException, TokenStreamException { |
7258 | |
7259 | returnAST = null; |
7260 | ASTPair currentAST = new ASTPair(); |
7261 | AST constant_AST = null; |
7262 | |
7263 | switch ( LA(1)) { |
7264 | case NUM_INT: |
7265 | { |
7266 | AST tmp259_AST = null; |
7267 | tmp259_AST = astFactory.create(LT(1)); |
7268 | astFactory.addASTChild(currentAST, tmp259_AST); |
7269 | match(NUM_INT); |
7270 | constant_AST = (AST)currentAST.root; |
7271 | break; |
7272 | } |
7273 | case CHAR_LITERAL: |
7274 | { |
7275 | AST tmp260_AST = null; |
7276 | tmp260_AST = astFactory.create(LT(1)); |
7277 | astFactory.addASTChild(currentAST, tmp260_AST); |
7278 | match(CHAR_LITERAL); |
7279 | constant_AST = (AST)currentAST.root; |
7280 | break; |
7281 | } |
7282 | case STRING_LITERAL: |
7283 | { |
7284 | AST tmp261_AST = null; |
7285 | tmp261_AST = astFactory.create(LT(1)); |
7286 | astFactory.addASTChild(currentAST, tmp261_AST); |
7287 | match(STRING_LITERAL); |
7288 | constant_AST = (AST)currentAST.root; |
7289 | break; |
7290 | } |
7291 | case NUM_FLOAT: |
7292 | { |
7293 | AST tmp262_AST = null; |
7294 | tmp262_AST = astFactory.create(LT(1)); |
7295 | astFactory.addASTChild(currentAST, tmp262_AST); |
7296 | match(NUM_FLOAT); |
7297 | constant_AST = (AST)currentAST.root; |
7298 | break; |
7299 | } |
7300 | case NUM_LONG: |
7301 | { |
7302 | AST tmp263_AST = null; |
7303 | tmp263_AST = astFactory.create(LT(1)); |
7304 | astFactory.addASTChild(currentAST, tmp263_AST); |
7305 | match(NUM_LONG); |
7306 | constant_AST = (AST)currentAST.root; |
7307 | break; |
7308 | } |
7309 | case NUM_DOUBLE: |
7310 | { |
7311 | AST tmp264_AST = null; |
7312 | tmp264_AST = astFactory.create(LT(1)); |
7313 | astFactory.addASTChild(currentAST, tmp264_AST); |
7314 | match(NUM_DOUBLE); |
7315 | constant_AST = (AST)currentAST.root; |
7316 | break; |
7317 | } |
7318 | default: |
7319 | { |
7320 | throw new NoViableAltException(LT(1), getFilename()); |
7321 | } |
7322 | } |
7323 | returnAST = constant_AST; |
7324 | } |
7325 | |
7326 | public final void newArrayDeclarator() throws RecognitionException, TokenStreamException { |
7327 | |
7328 | returnAST = null; |
7329 | ASTPair currentAST = new ASTPair(); |
7330 | AST newArrayDeclarator_AST = null; |
7331 | Token lb = null; |
7332 | AST lb_AST = null; |
7333 | |
7334 | { |
7335 | int _cnt319=0; |
7336 | _loop319: |
7337 | do { |
7338 | if ((LA(1)==LBRACK) && (_tokenSet_48.member(LA(2)))) { |
7339 | lb = LT(1); |
7340 | lb_AST = astFactory.create(lb); |
7341 | astFactory.makeASTRoot(currentAST, lb_AST); |
7342 | match(LBRACK); |
7343 | if ( inputState.guessing==0 ) { |
7344 | lb_AST.setType(ARRAY_DECLARATOR); |
7345 | } |
7346 | { |
7347 | switch ( LA(1)) { |
7348 | case IDENT: |
7349 | case LITERAL_super: |
7350 | case LT: |
7351 | case LITERAL_void: |
7352 | case LITERAL_boolean: |
7353 | case LITERAL_byte: |
7354 | case LITERAL_char: |
7355 | case LITERAL_short: |
7356 | case LITERAL_int: |
7357 | case LITERAL_float: |
7358 | case LITERAL_long: |
7359 | case LITERAL_double: |
7360 | case LPAREN: |
7361 | case LITERAL_this: |
7362 | case PLUS: |
7363 | case MINUS: |
7364 | case INC: |
7365 | case DEC: |
7366 | case BNOT: |
7367 | case LNOT: |
7368 | case LITERAL_true: |
7369 | case LITERAL_false: |
7370 | case LITERAL_null: |
7371 | case LITERAL_new: |
7372 | case NUM_INT: |
7373 | case CHAR_LITERAL: |
7374 | case STRING_LITERAL: |
7375 | case NUM_FLOAT: |
7376 | case NUM_LONG: |
7377 | case NUM_DOUBLE: |
7378 | { |
7379 | expression(); |
7380 | astFactory.addASTChild(currentAST, returnAST); |
7381 | break; |
7382 | } |
7383 | case RBRACK: |
7384 | { |
7385 | break; |
7386 | } |
7387 | default: |
7388 | { |
7389 | throw new NoViableAltException(LT(1), getFilename()); |
7390 | } |
7391 | } |
7392 | } |
7393 | match(RBRACK); |
7394 | } |
7395 | else { |
7396 | if ( _cnt319>=1 ) { break _loop319; } else {throw new NoViableAltException(LT(1), getFilename());} |
7397 | } |
7398 | |
7399 | _cnt319++; |
7400 | } while (true); |
7401 | } |
7402 | newArrayDeclarator_AST = (AST)currentAST.root; |
7403 | returnAST = newArrayDeclarator_AST; |
7404 | } |
7405 | |
7406 | |
7407 | public static final String[] _tokenNames = { |
7408 | "<0>", |
7409 | "EOF", |
7410 | "<2>", |
7411 | "NULL_TREE_LOOKAHEAD", |
7412 | "BLOCK", |
7413 | "MODIFIERS", |
7414 | "OBJBLOCK", |
7415 | "SLIST", |
7416 | "CTOR_DEF", |
7417 | "METHOD_DEF", |
7418 | "VARIABLE_DEF", |
7419 | "INSTANCE_INIT", |
7420 | "STATIC_INIT", |
7421 | "TYPE", |
7422 | "CLASS_DEF", |
7423 | "INTERFACE_DEF", |
7424 | "PACKAGE_DEF", |
7425 | "ARRAY_DECLARATOR", |
7426 | "EXTENDS_CLAUSE", |
7427 | "IMPLEMENTS_CLAUSE", |
7428 | "PARAMETERS", |
7429 | "PARAMETER_DEF", |
7430 | "LABELED_STAT", |
7431 | "TYPECAST", |
7432 | "INDEX_OP", |
7433 | "POST_INC", |
7434 | "POST_DEC", |
7435 | "METHOD_CALL", |
7436 | "EXPR", |
7437 | "ARRAY_INIT", |
7438 | "IMPORT", |
7439 | "UNARY_MINUS", |
7440 | "UNARY_PLUS", |
7441 | "CASE_GROUP", |
7442 | "ELIST", |
7443 | "FOR_INIT", |
7444 | "FOR_CONDITION", |
7445 | "FOR_ITERATOR", |
7446 | "EMPTY_STAT", |
7447 | "\"final\"", |
7448 | "\"abstract\"", |
7449 | "\"strictfp\"", |
7450 | "SUPER_CTOR_CALL", |
7451 | "CTOR_CALL", |
7452 | "VARIABLE_PARAMETER_DEF", |
7453 | "STATIC_IMPORT", |
7454 | "ENUM_DEF", |
7455 | "ENUM_CONSTANT_DEF", |
7456 | "FOR_EACH_CLAUSE", |
7457 | "ANNOTATION_DEF", |
7458 | "ANNOTATIONS", |
7459 | "ANNOTATION", |
7460 | "ANNOTATION_MEMBER_VALUE_PAIR", |
7461 | "ANNOTATION_FIELD_DEF", |
7462 | "ANNOTATION_ARRAY_INIT", |
7463 | "TYPE_ARGUMENTS", |
7464 | "TYPE_ARGUMENT", |
7465 | "TYPE_PARAMETERS", |
7466 | "TYPE_PARAMETER", |
7467 | "WILDCARD_TYPE", |
7468 | "TYPE_UPPER_BOUNDS", |
7469 | "TYPE_LOWER_BOUNDS", |
7470 | "\"package\"", |
7471 | "SEMI", |
7472 | "\"import\"", |
7473 | "\"static\"", |
7474 | "LBRACK", |
7475 | "RBRACK", |
7476 | "IDENT", |
7477 | "DOT", |
7478 | "QUESTION", |
7479 | "\"extends\"", |
7480 | "\"super\"", |
7481 | "LT", |
7482 | "COMMA", |
7483 | "GT", |
7484 | "SR", |
7485 | "BSR", |
7486 | "\"void\"", |
7487 | "\"boolean\"", |
7488 | "\"byte\"", |
7489 | "\"char\"", |
7490 | "\"short\"", |
7491 | "\"int\"", |
7492 | "\"float\"", |
7493 | "\"long\"", |
7494 | "\"double\"", |
7495 | "STAR", |
7496 | "\"private\"", |
7497 | "\"public\"", |
7498 | "\"protected\"", |
7499 | "\"transient\"", |
7500 | "\"native\"", |
7501 | "\"threadsafe\"", |
7502 | "\"synchronized\"", |
7503 | "\"volatile\"", |
7504 | "AT", |
7505 | "LPAREN", |
7506 | "RPAREN", |
7507 | "ASSIGN", |
7508 | "LCURLY", |
7509 | "RCURLY", |
7510 | "\"class\"", |
7511 | "\"interface\"", |
7512 | "\"enum\"", |
7513 | "BAND", |
7514 | "\"default\"", |
7515 | "\"implements\"", |
7516 | "\"this\"", |
7517 | "\"throws\"", |
7518 | "TRIPLE_DOT", |
7519 | "COLON", |
7520 | "\"if\"", |
7521 | "\"else\"", |
7522 | "\"while\"", |
7523 | "\"do\"", |
7524 | "\"break\"", |
7525 | "\"continue\"", |
7526 | "\"return\"", |
7527 | "\"switch\"", |
7528 | "\"throw\"", |
7529 | "\"assert\"", |
7530 | "\"for\"", |
7531 | "\"case\"", |
7532 | "\"try\"", |
7533 | "\"finally\"", |
7534 | "\"catch\"", |
7535 | "PLUS_ASSIGN", |
7536 | "MINUS_ASSIGN", |
7537 | "STAR_ASSIGN", |
7538 | "DIV_ASSIGN", |
7539 | "MOD_ASSIGN", |
7540 | "SR_ASSIGN", |
7541 | "BSR_ASSIGN", |
7542 | "SL_ASSIGN", |
7543 | "BAND_ASSIGN", |
7544 | "BXOR_ASSIGN", |
7545 | "BOR_ASSIGN", |
7546 | "LOR", |
7547 | "LAND", |
7548 | "BOR", |
7549 | "BXOR", |
7550 | "NOT_EQUAL", |
7551 | "EQUAL", |
7552 | "LE", |
7553 | "GE", |
7554 | "\"instanceof\"", |
7555 | "SL", |
7556 | "PLUS", |
7557 | "MINUS", |
7558 | "DIV", |
7559 | "MOD", |
7560 | "INC", |
7561 | "DEC", |
7562 | "BNOT", |
7563 | "LNOT", |
7564 | "\"true\"", |
7565 | "\"false\"", |
7566 | "\"null\"", |
7567 | "\"new\"", |
7568 | "NUM_INT", |
7569 | "CHAR_LITERAL", |
7570 | "STRING_LITERAL", |
7571 | "NUM_FLOAT", |
7572 | "NUM_LONG", |
7573 | "NUM_DOUBLE", |
7574 | "WS", |
7575 | "SL_COMMENT", |
7576 | "ML_COMMENT", |
7577 | "ESC", |
7578 | "HEX_DIGIT", |
7579 | "VOCAB", |
7580 | "EXPONENT", |
7581 | "FLOAT_SUFFIX" |
7582 | }; |
7583 | |
7584 | protected void buildTokenTypeASTClassMap() { |
7585 | tokenTypeToASTClassMap=null; |
7586 | }; |
7587 | |
7588 | private static final long[] mk_tokenSet_0() { |
7589 | long[] data = { -9223368188564078590L, 1932718505987L, 0L, 0L}; |
7590 | return data; |
7591 | } |
7592 | public static final BitSet _tokenSet_0 = new BitSet(mk_tokenSet_0()); |
7593 | private static final long[] mk_tokenSet_1() { |
7594 | long[] data = { -9223368188564078590L, 1932718506002L, 0L, 0L}; |
7595 | return data; |
7596 | } |
7597 | public static final BitSet _tokenSet_1 = new BitSet(mk_tokenSet_1()); |
7598 | private static final long[] mk_tokenSet_2() { |
7599 | long[] data = { -9223368188564078592L, 1932718505986L, 0L, 0L}; |
7600 | return data; |
7601 | } |
7602 | public static final BitSet _tokenSet_2 = new BitSet(mk_tokenSet_2()); |
7603 | private static final long[] mk_tokenSet_3() { |
7604 | long[] data = { -9223368188564078590L, 1932718505986L, 0L, 0L}; |
7605 | return data; |
7606 | } |
7607 | public static final BitSet _tokenSet_3 = new BitSet(mk_tokenSet_3()); |
7608 | private static final long[] mk_tokenSet_4() { |
7609 | long[] data = { 3848290697216L, 4278190082L, 0L, 0L}; |
7610 | return data; |
7611 | } |
7612 | public static final BitSet _tokenSet_4 = new BitSet(mk_tokenSet_4()); |
7613 | private static final long[] mk_tokenSet_5() { |
7614 | long[] data = { 0L, 8372304L, 0L, 0L}; |
7615 | return data; |
7616 | } |
7617 | public static final BitSet _tokenSet_5 = new BitSet(mk_tokenSet_5()); |
7618 | private static final long[] mk_tokenSet_6() { |
7619 | long[] data = { -9223372036854775808L, -9223132077023560196L, 65535L, 0L, 0L, 0L}; |
7620 | return data; |
7621 | } |
7622 | public static final BitSet _tokenSet_6 = new BitSet(mk_tokenSet_6()); |
7623 | private static final long[] mk_tokenSet_7() { |
7624 | long[] data = { -4611682170136690688L, -6917564212013170690L, 274877906943L, 0L, 0L, 0L}; |
7625 | return data; |
7626 | } |
7627 | public static final BitSet _tokenSet_7 = new BitSet(mk_tokenSet_7()); |
7628 | private static final long[] mk_tokenSet_8() { |
7629 | long[] data = { 0L, 17673798796048L, 274864275456L, 0L, 0L, 0L}; |
7630 | return data; |
7631 | } |
7632 | public static final BitSet _tokenSet_8 = new BitSet(mk_tokenSet_8()); |
7633 | private static final long[] mk_tokenSet_9() { |
7634 | long[] data = { 0L, 19958729800564L, 274877905920L, 0L, 0L, 0L}; |
7635 | return data; |
7636 | } |
7637 | public static final BitSet _tokenSet_9 = new BitSet(mk_tokenSet_9()); |
7638 | private static final long[] mk_tokenSet_10() { |
7639 | long[] data = { 0L, 17605079319312L, 274864275456L, 0L, 0L, 0L}; |
7640 | return data; |
7641 | } |
7642 | public static final BitSet _tokenSet_10 = new BitSet(mk_tokenSet_10()); |
7643 | private static final long[] mk_tokenSet_11() { |
7644 | long[] data = { 0L, 8864820886672L, 0L, 0L}; |
7645 | return data; |
7646 | } |
7647 | public static final BitSet _tokenSet_11 = new BitSet(mk_tokenSet_11()); |
7648 | private static final long[] mk_tokenSet_12() { |
7649 | long[] data = { -9223368188564078592L, 10943568265910L, 0L, 0L}; |
7650 | return data; |
7651 | } |
7652 | public static final BitSet _tokenSet_12 = new BitSet(mk_tokenSet_12()); |
7653 | private static final long[] mk_tokenSet_13() { |
7654 | long[] data = { 3848290697216L, 1932726878738L, 0L, 0L}; |
7655 | return data; |
7656 | } |
7657 | public static final BitSet _tokenSet_13 = new BitSet(mk_tokenSet_13()); |
7658 | private static final long[] mk_tokenSet_14() { |
7659 | long[] data = { 3848290697216L, 1941316813366L, 0L, 0L}; |
7660 | return data; |
7661 | } |
7662 | public static final BitSet _tokenSet_14 = new BitSet(mk_tokenSet_14()); |
7663 | private static final long[] mk_tokenSet_15() { |
7664 | long[] data = { 0L, 8372240L, 0L, 0L}; |
7665 | return data; |
7666 | } |
7667 | public static final BitSet _tokenSet_15 = new BitSet(mk_tokenSet_15()); |
7668 | private static final long[] mk_tokenSet_16() { |
7669 | long[] data = { 0L, 564L, 0L, 0L}; |
7670 | return data; |
7671 | } |
7672 | public static final BitSet _tokenSet_16 = new BitSet(mk_tokenSet_16()); |
7673 | private static final long[] mk_tokenSet_17() { |
7674 | long[] data = { -9223372036854775808L, 34359739396L, 0L, 0L}; |
7675 | return data; |
7676 | } |
7677 | public static final BitSet _tokenSet_17 = new BitSet(mk_tokenSet_17()); |
7678 | private static final long[] mk_tokenSet_18() { |
7679 | long[] data = { 549755813888L, 4303339536L, 0L, 0L}; |
7680 | return data; |
7681 | } |
7682 | public static final BitSet _tokenSet_18 = new BitSet(mk_tokenSet_18()); |
7683 | private static final long[] mk_tokenSet_19() { |
7684 | long[] data = { 0L, 4303340084L, 0L, 0L}; |
7685 | return data; |
7686 | } |
7687 | public static final BitSet _tokenSet_19 = new BitSet(mk_tokenSet_19()); |
7688 | private static final long[] mk_tokenSet_20() { |
7689 | long[] data = { 0L, 70373047517748L, 0L, 0L}; |
7690 | return data; |
7691 | } |
7692 | public static final BitSet _tokenSet_20 = new BitSet(mk_tokenSet_20()); |
7693 | private static final long[] mk_tokenSet_21() { |
7694 | long[] data = { -9223368188564078592L, 1728555784935031570L, 274864275456L, 0L, 0L, 0L}; |
7695 | return data; |
7696 | } |
7697 | public static final BitSet _tokenSet_21 = new BitSet(mk_tokenSet_21()); |
7698 | private static final long[] mk_tokenSet_22() { |
7699 | long[] data = { 0L, 17592186045184L, 0L, 0L}; |
7700 | return data; |
7701 | } |
7702 | public static final BitSet _tokenSet_22 = new BitSet(mk_tokenSet_22()); |
7703 | private static final long[] mk_tokenSet_23() { |
7704 | long[] data = { 0L, 8598306896L, 0L, 0L}; |
7705 | return data; |
7706 | } |
7707 | public static final BitSet _tokenSet_23 = new BitSet(mk_tokenSet_23()); |
7708 | private static final long[] mk_tokenSet_24() { |
7709 | long[] data = { -9223368188564078592L, 1728555922373985042L, 274864275456L, 0L, 0L, 0L}; |
7710 | return data; |
7711 | } |
7712 | public static final BitSet _tokenSet_24 = new BitSet(mk_tokenSet_24()); |
7713 | private static final long[] mk_tokenSet_25() { |
7714 | long[] data = { -9223368188564078592L, -7494671494333596810L, 274877906943L, 0L, 0L, 0L}; |
7715 | return data; |
7716 | } |
7717 | public static final BitSet _tokenSet_25 = new BitSet(mk_tokenSet_25()); |
7718 | private static final long[] mk_tokenSet_26() { |
7719 | long[] data = { -9223368188564078592L, 2305584022677340946L, 274864275456L, 0L, 0L, 0L}; |
7720 | return data; |
7721 | } |
7722 | public static final BitSet _tokenSet_26 = new BitSet(mk_tokenSet_26()); |
7723 | private static final long[] mk_tokenSet_27() { |
7724 | long[] data = { -9223368188564078592L, -114366389159050L, 274877906943L, 0L, 0L, 0L}; |
7725 | return data; |
7726 | } |
7727 | public static final BitSet _tokenSet_27 = new BitSet(mk_tokenSet_27()); |
7728 | private static final long[] mk_tokenSet_28() { |
7729 | long[] data = { 3848290697216L, 8581529618L, 0L, 0L}; |
7730 | return data; |
7731 | } |
7732 | public static final BitSet _tokenSet_28 = new BitSet(mk_tokenSet_28()); |
7733 | private static final long[] mk_tokenSet_29() { |
7734 | long[] data = { 3848290697216L, 8581530166L, 0L, 0L}; |
7735 | return data; |
7736 | } |
7737 | public static final BitSet _tokenSet_29 = new BitSet(mk_tokenSet_29()); |
7738 | private static final long[] mk_tokenSet_30() { |
7739 | long[] data = { 0L, 17600784352016L, 274864275456L, 0L, 0L, 0L}; |
7740 | return data; |
7741 | } |
7742 | public static final BitSet _tokenSet_30 = new BitSet(mk_tokenSet_30()); |
7743 | private static final long[] mk_tokenSet_31() { |
7744 | long[] data = { -9223372036854775808L, -9223352202679026828L, 274877906943L, 0L, 0L, 0L}; |
7745 | return data; |
7746 | } |
7747 | public static final BitSet _tokenSet_31 = new BitSet(mk_tokenSet_31()); |
7748 | private static final long[] mk_tokenSet_32() { |
7749 | long[] data = { 3848290697216L, 283451064322L, 0L, 0L}; |
7750 | return data; |
7751 | } |
7752 | public static final BitSet _tokenSet_32 = new BitSet(mk_tokenSet_32()); |
7753 | private static final long[] mk_tokenSet_33() { |
7754 | long[] data = { 3848290697216L, 283451064338L, 0L, 0L}; |
7755 | return data; |
7756 | } |
7757 | public static final BitSet _tokenSet_33 = new BitSet(mk_tokenSet_33()); |
7758 | private static final long[] mk_tokenSet_34() { |
7759 | long[] data = { 0L, 17669503828752L, 274864275456L, 0L, 0L, 0L}; |
7760 | return data; |
7761 | } |
7762 | public static final BitSet _tokenSet_34 = new BitSet(mk_tokenSet_34()); |
7763 | private static final long[] mk_tokenSet_35() { |
7764 | long[] data = { -9223368188564078592L, 17609357509394L, 274864275456L, 0L, 0L, 0L}; |
7765 | return data; |
7766 | } |
7767 | public static final BitSet _tokenSet_35 = new BitSet(mk_tokenSet_35()); |
7768 | private static final long[] mk_tokenSet_36() { |
7769 | long[] data = { -9223368188564078592L, -9223352194105868426L, 274877906943L, 0L, 0L, 0L}; |
7770 | return data; |
7771 | } |
7772 | public static final BitSet _tokenSet_36 = new BitSet(mk_tokenSet_36()); |
7773 | private static final long[] mk_tokenSet_37() { |
7774 | long[] data = { 0L, 158338272707344L, 274864275456L, 0L, 0L, 0L}; |
7775 | return data; |
7776 | } |
7777 | public static final BitSet _tokenSet_37 = new BitSet(mk_tokenSet_37()); |
7778 | private static final long[] mk_tokenSet_38() { |
7779 | long[] data = { -9223372036854775808L, -9223352202679025804L, 274877906943L, 0L, 0L, 0L}; |
7780 | return data; |
7781 | } |
7782 | public static final BitSet _tokenSet_38 = new BitSet(mk_tokenSet_38()); |
7783 | private static final long[] mk_tokenSet_39() { |
7784 | long[] data = { 0L, 2560L, 196608L, 0L, 0L, 0L}; |
7785 | return data; |
7786 | } |
7787 | public static final BitSet _tokenSet_39 = new BitSet(mk_tokenSet_39()); |
7788 | private static final long[] mk_tokenSet_40() { |
7789 | long[] data = { 0L, 12288L, 524288L, 0L, 0L, 0L}; |
7790 | return data; |
7791 | } |
7792 | public static final BitSet _tokenSet_40 = new BitSet(mk_tokenSet_40()); |
7793 | private static final long[] mk_tokenSet_41() { |
7794 | long[] data = { 0L, 8388608L, 12582912L, 0L, 0L, 0L}; |
7795 | return data; |
7796 | } |
7797 | public static final BitSet _tokenSet_41 = new BitSet(mk_tokenSet_41()); |
7798 | private static final long[] mk_tokenSet_42() { |
7799 | long[] data = { 0L, 17600784352016L, 274609471488L, 0L, 0L, 0L}; |
7800 | return data; |
7801 | } |
7802 | public static final BitSet _tokenSet_42 = new BitSet(mk_tokenSet_42()); |
7803 | private static final long[] mk_tokenSet_43() { |
7804 | long[] data = { -9223372036854775808L, -9223211310571847812L, 274877906943L, 0L, 0L, 0L}; |
7805 | return data; |
7806 | } |
7807 | public static final BitSet _tokenSet_43 = new BitSet(mk_tokenSet_43()); |
7808 | private static final long[] mk_tokenSet_44() { |
7809 | long[] data = { 0L, 784L, 0L, 0L}; |
7810 | return data; |
7811 | } |
7812 | public static final BitSet _tokenSet_44 = new BitSet(mk_tokenSet_44()); |
7813 | private static final long[] mk_tokenSet_45() { |
7814 | long[] data = { -9223372036854775808L, -9223228911356199316L, 67108863L, 0L, 0L, 0L}; |
7815 | return data; |
7816 | } |
7817 | public static final BitSet _tokenSet_45 = new BitSet(mk_tokenSet_45()); |
7818 | private static final long[] mk_tokenSet_46() { |
7819 | long[] data = { -4611682170136690688L, -6917643376850370690L, 274877906943L, 0L, 0L, 0L}; |
7820 | return data; |
7821 | } |
7822 | public static final BitSet _tokenSet_46 = new BitSet(mk_tokenSet_46()); |
7823 | private static final long[] mk_tokenSet_47() { |
7824 | long[] data = { -9223372036854775808L, -9223228902766264724L, 67108863L, 0L, 0L, 0L}; |
7825 | return data; |
7826 | } |
7827 | public static final BitSet _tokenSet_47 = new BitSet(mk_tokenSet_47()); |
7828 | private static final long[] mk_tokenSet_48() { |
7829 | long[] data = { 0L, 17600784352024L, 274864275456L, 0L, 0L, 0L}; |
7830 | return data; |
7831 | } |
7832 | public static final BitSet _tokenSet_48 = new BitSet(mk_tokenSet_48()); |
7833 | |
7834 | } |