Coverage Report - com.puppycrawl.tools.checkstyle.grammars.GeneratedJavaRecognizer
 
Classes in this File Line Coverage Branch Coverage Complexity
GeneratedJavaRecognizer
96%
4241/4400
73%
1135/1550
11.144
 
 1  
 // $ANTLR 2.7.7 (20060906): "java.g" -> "GeneratedJavaRecognizer.java"$
 2  
 
 3  
 package com.puppycrawl.tools.checkstyle.grammars;
 4  
 
 5  
 import com.puppycrawl.tools.checkstyle.api.DetailAST;
 6  
 import java.text.MessageFormat;
 7  
 import antlr.CommonHiddenStreamToken;
 8  
 
 9  
 import antlr.TokenBuffer;
 10  
 import antlr.TokenStreamException;
 11  
 import antlr.TokenStreamIOException;
 12  
 import antlr.ANTLRException;
 13  
 import antlr.LLkParser;
 14  
 import antlr.Token;
 15  
 import antlr.TokenStream;
 16  
 import antlr.RecognitionException;
 17  
 import antlr.NoViableAltException;
 18  
 import antlr.MismatchedTokenException;
 19  
 import antlr.SemanticException;
 20  
 import antlr.ParserSharedInputState;
 21  
 import antlr.collections.impl.BitSet;
 22  
 import antlr.collections.AST;
 23  
 import java.util.Hashtable;
 24  
 import antlr.ASTFactory;
 25  
 import antlr.ASTPair;
 26  
 import antlr.collections.impl.ASTArray;
 27  
 
 28  
 /** Java 1.5 Recognizer
 29  
  *
 30  
  * This grammar is in the PUBLIC DOMAIN
 31  
  */
 32  
 public class GeneratedJavaRecognizer extends antlr.LLkParser       implements GeneratedJavaTokenTypes
 33  
  {
 34  
 
 35  
     /**
 36  
      * Counts the number of LT seen in the typeArguments production.
 37  
      * It is used in semantic predicates to ensure we have seen
 38  
      * enough closing '>' characters; which actually may have been
 39  
      * either GT, SR or BSR tokens.
 40  
      */
 41  2416
     private int ltCounter = 0;
 42  
 
 43  
     /**
 44  
      * Counts the number of '>' characters that have been seen but
 45  
      * have not yet been associated with the end of a typeParameters or
 46  
      * typeArguments production. This is necessary because SR and BSR
 47  
      * tokens have significance (the extra '>' characters) not only for the production
 48  
      * that sees them but also productions higher in the stack (possibly right up to an outer-most
 49  
      * typeParameters production). As the stack of the typeArguments/typeParameters productions
 50  
      * unwind, any '>' characters seen prematurely through SRs or BSRs are reconciled.
 51  
      */
 52  2416
     private int gtToReconcile = 0;
 53  
 
 54  
     /**
 55  
      * The most recently seen gt sequence (GT, SR or BSR)
 56  
      * encountered in any type argument or type parameter production.
 57  
      * We retain this so we can keep manage the synthetic GT tokens/
 58  
      * AST nodes we emit to have '<' & '>' balanced trees when encountering
 59  
      * SR and BSR tokens.
 60  
      */
 61  2416
     private DetailAST currentGtSequence = null;
 62  
 
 63  
     /**
 64  
      * Consume a sequence of '>' characters (GT, SR or BSR)
 65  
      * and match these against the '<' characters seen.
 66  
      */
 67  
     private void consumeCurrentGtSequence(DetailAST gtSequence)
 68  
     {
 69  2047
         currentGtSequence = gtSequence;
 70  2047
         gtToReconcile += currentGtSequence.getText().length();
 71  2047
         ltCounter -= currentGtSequence.getText().length();
 72  2047
     }
 73  
 
 74  
     /**
 75  
      * Emits a single GT AST node with the line and column correctly
 76  
      * set to its position in the source file. This must only
 77  
      * ever be called when a typeParameters or typeArguments production
 78  
      * is ending and there is at least one GT character to be emitted.
 79  
      *
 80  
      * @see #areThereGtsToEmit
 81  
      */
 82  
     private DetailAST emitSingleGt()
 83  
     {
 84  2216
         gtToReconcile -= 1;
 85  2216
         CommonHiddenStreamToken gtToken = new CommonHiddenStreamToken(GENERIC_END, ">");
 86  2216
         gtToken.setLine(currentGtSequence.getLineNo());
 87  4432
         gtToken.setColumn(currentGtSequence.getColumnNo()
 88  2216
                             + (currentGtSequence.getText().length() - gtToReconcile));
 89  2216
         return (DetailAST)astFactory.create(gtToken);
 90  
     }
 91  
 
 92  
     /**
 93  
      * @return true if there is at least one '>' seen but
 94  
      * not reconciled with the end of a typeParameters or
 95  
      * typeArguments production; returns false otherwise
 96  
      */
 97  
     private boolean areThereGtsToEmit()
 98  
     {
 99  1621
         return (gtToReconcile > 0);
 100  
     }
 101  
 
 102  
     /**
 103  
      * @return true if there is exactly one '>' seen but
 104  
      * not reconciled with the end of a typeParameters
 105  
      * production; returns false otherwise
 106  
      */
 107  
     private boolean isThereASingleGtToEmit()
 108  
     {
 109  595
         return (gtToReconcile == 1);
 110  
     }
 111  
 
 112  
     /**
 113  
      * @return true if the '<' and '>' are evenly matched
 114  
      * at the current typeParameters/typeArguments nested depth
 115  
      */
 116  
     private boolean areLtsAndGtsBalanced(int currentLtLevel)
 117  
     {
 118  4355
         return ((currentLtLevel != 0) || ltCounter == currentLtLevel);
 119  
     }
 120  
 
 121  
 protected GeneratedJavaRecognizer(TokenBuffer tokenBuf, int k) {
 122  1
   super(tokenBuf,k);
 123  1
   tokenNames = _tokenNames;
 124  1
   buildTokenTypeASTClassMap();
 125  1
   astFactory = new ASTFactory(getTokenTypeToASTClassMap());
 126  1
 }
 127  
 
 128  
 public GeneratedJavaRecognizer(TokenBuffer tokenBuf) {
 129  1
   this(tokenBuf,2);
 130  1
 }
 131  
 
 132  
 protected GeneratedJavaRecognizer(TokenStream lexer, int k) {
 133  2414
   super(lexer,k);
 134  2414
   tokenNames = _tokenNames;
 135  2414
   buildTokenTypeASTClassMap();
 136  2414
   astFactory = new ASTFactory(getTokenTypeToASTClassMap());
 137  2414
 }
 138  
 
 139  
 public GeneratedJavaRecognizer(TokenStream lexer) {
 140  2414
   this(lexer,2);
 141  2414
 }
 142  
 
 143  
 public GeneratedJavaRecognizer(ParserSharedInputState state) {
 144  1
   super(state,2);
 145  1
   tokenNames = _tokenNames;
 146  1
   buildTokenTypeASTClassMap();
 147  1
   astFactory = new ASTFactory(getTokenTypeToASTClassMap());
 148  1
 }
 149  
 
 150  
         public final void compilationUnit() throws RecognitionException, TokenStreamException {
 151  
                 
 152  2414
                 returnAST = null;
 153  2414
                 ASTPair currentAST = new ASTPair();
 154  2414
                 AST compilationUnit_AST = null;
 155  
                 
 156  
                 {
 157  2414
                 boolean synPredMatched4 = false;
 158  2414
                 if (((LA(1)==LITERAL_package||LA(1)==AT) && (LA(2)==IDENT))) {
 159  2325
                         int _m4 = mark();
 160  2325
                         synPredMatched4 = true;
 161  2325
                         inputState.guessing++;
 162  
                         try {
 163  
                                 {
 164  2325
                                 annotations();
 165  2325
                                 match(LITERAL_package);
 166  
                                 }
 167  
                         }
 168  0
                         catch (RecognitionException pe) {
 169  0
                                 synPredMatched4 = false;
 170  2325
                         }
 171  2325
                         rewind(_m4);
 172  2325
 inputState.guessing--;
 173  
                 }
 174  2414
                 if ( synPredMatched4 ) {
 175  2325
                         packageDefinition();
 176  2325
                         astFactory.addASTChild(currentAST, returnAST);
 177  
                 }
 178  89
                 else if ((_tokenSet_0.member(LA(1))) && (_tokenSet_1.member(LA(2)))) {
 179  
                 }
 180  
                 else {
 181  4
                         throw new NoViableAltException(LT(1), getFilename());
 182  
                 }
 183  
                 
 184  
                 }
 185  
                 {
 186  
                 _loop6:
 187  
                 do {
 188  5838
                         if ((LA(1)==SEMI||LA(1)==LITERAL_import) && (_tokenSet_1.member(LA(2)))) {
 189  3428
                                 importDefinition();
 190  3428
                                 astFactory.addASTChild(currentAST, returnAST);
 191  
                         }
 192  
                         else {
 193  
                                 break _loop6;
 194  
                         }
 195  
                         
 196  
                 } while (true);
 197  
                 }
 198  
                 {
 199  
                 _loop8:
 200  
                 do {
 201  6755
                         if ((_tokenSet_2.member(LA(1)))) {
 202  4349
                                 typeDefinition();
 203  4345
                                 astFactory.addASTChild(currentAST, returnAST);
 204  
                         }
 205  
                         else {
 206  
                                 break _loop8;
 207  
                         }
 208  
                         
 209  
                 } while (true);
 210  
                 }
 211  2406
                 match(Token.EOF_TYPE);
 212  2405
                 compilationUnit_AST = (AST)currentAST.root;
 213  2405
                 returnAST = compilationUnit_AST;
 214  2405
         }
 215  
         
 216  
         public final void annotations() throws RecognitionException, TokenStreamException {
 217  
                 
 218  5663
                 returnAST = null;
 219  5663
                 ASTPair currentAST = new ASTPair();
 220  5663
                 AST annotations_AST = null;
 221  
                 
 222  
                 {
 223  
                 _loop68:
 224  
                 do {
 225  6055
                         if ((LA(1)==AT) && (LA(2)==IDENT)) {
 226  392
                                 annotation();
 227  392
                                 astFactory.addASTChild(currentAST, returnAST);
 228  
                         }
 229  
                         else {
 230  
                                 break _loop68;
 231  
                         }
 232  
                         
 233  
                 } while (true);
 234  
                 }
 235  5663
                 if ( inputState.guessing==0 ) {
 236  3188
                         annotations_AST = (AST)currentAST.root;
 237  3188
                         annotations_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(ANNOTATIONS,"ANNOTATIONS")).add(annotations_AST));
 238  3188
                         currentAST.root = annotations_AST;
 239  3188
                         currentAST.child = annotations_AST!=null &&annotations_AST.getFirstChild()!=null ?
 240  191
                                 annotations_AST.getFirstChild() : annotations_AST;
 241  3188
                         currentAST.advanceChildToEnd();
 242  
                 }
 243  5663
                 annotations_AST = (AST)currentAST.root;
 244  5663
                 returnAST = annotations_AST;
 245  5663
         }
 246  
         
 247  
         public final void packageDefinition() throws RecognitionException, TokenStreamException {
 248  
                 
 249  2325
                 returnAST = null;
 250  2325
                 ASTPair currentAST = new ASTPair();
 251  2325
                 AST packageDefinition_AST = null;
 252  2325
                 Token  p = null;
 253  2325
                 AST p_AST = null;
 254  
                 
 255  
                 try {      // for error handling
 256  2325
                         annotations();
 257  2325
                         astFactory.addASTChild(currentAST, returnAST);
 258  2325
                         p = LT(1);
 259  2325
                         p_AST = astFactory.create(p);
 260  2325
                         astFactory.makeASTRoot(currentAST, p_AST);
 261  2325
                         match(LITERAL_package);
 262  2325
                         if ( inputState.guessing==0 ) {
 263  2325
                                 p_AST.setType(PACKAGE_DEF);
 264  
                         }
 265  2325
                         identifier();
 266  2325
                         astFactory.addASTChild(currentAST, returnAST);
 267  2325
                         AST tmp2_AST = null;
 268  2325
                         tmp2_AST = astFactory.create(LT(1));
 269  2325
                         astFactory.addASTChild(currentAST, tmp2_AST);
 270  2325
                         match(SEMI);
 271  2325
                         packageDefinition_AST = (AST)currentAST.root;
 272  
                 }
 273  0
                 catch (RecognitionException ex) {
 274  0
                         if (inputState.guessing==0) {
 275  0
                                 reportError(ex);
 276  0
                                 recover(ex,_tokenSet_0);
 277  
                         } else {
 278  0
                           throw ex;
 279  
                         }
 280  2325
                 }
 281  2325
                 returnAST = packageDefinition_AST;
 282  2325
         }
 283  
         
 284  
         public final void importDefinition() throws RecognitionException, TokenStreamException {
 285  
                 
 286  3428
                 returnAST = null;
 287  3428
                 ASTPair currentAST = new ASTPair();
 288  3428
                 AST importDefinition_AST = null;
 289  3428
                 Token  i = null;
 290  3428
                 AST i_AST = null;
 291  
                 
 292  
                 try {      // for error handling
 293  3428
                         switch ( LA(1)) {
 294  
                         case LITERAL_import:
 295  
                         {
 296  3422
                                 i = LT(1);
 297  3422
                                 i_AST = astFactory.create(i);
 298  3422
                                 astFactory.makeASTRoot(currentAST, i_AST);
 299  3422
                                 match(LITERAL_import);
 300  3422
                                 if ( inputState.guessing==0 ) {
 301  3422
                                         i_AST.setType(IMPORT);
 302  
                                 }
 303  
                                 {
 304  3422
                                 switch ( LA(1)) {
 305  
                                 case LITERAL_static:
 306  
                                 {
 307  434
                                         AST tmp3_AST = null;
 308  434
                                         tmp3_AST = astFactory.create(LT(1));
 309  434
                                         astFactory.addASTChild(currentAST, tmp3_AST);
 310  434
                                         match(LITERAL_static);
 311  434
                                         if ( inputState.guessing==0 ) {
 312  434
                                                 i_AST.setType(STATIC_IMPORT);
 313  
                                         }
 314  
                                         break;
 315  
                                 }
 316  
                                 case IDENT:
 317  
                                 {
 318  2988
                                         break;
 319  
                                 }
 320  
                                 default:
 321  
                                 {
 322  0
                                         throw new NoViableAltException(LT(1), getFilename());
 323  
                                 }
 324  
                                 }
 325  
                                 }
 326  3422
                                 identifierStar();
 327  3422
                                 astFactory.addASTChild(currentAST, returnAST);
 328  3422
                                 AST tmp4_AST = null;
 329  3422
                                 tmp4_AST = astFactory.create(LT(1));
 330  3422
                                 astFactory.addASTChild(currentAST, tmp4_AST);
 331  3422
                                 match(SEMI);
 332  3422
                                 importDefinition_AST = (AST)currentAST.root;
 333  3422
                                 break;
 334  
                         }
 335  
                         case SEMI:
 336  
                         {
 337  6
                                 AST tmp5_AST = null;
 338  6
                                 tmp5_AST = astFactory.create(LT(1));
 339  6
                                 astFactory.addASTChild(currentAST, tmp5_AST);
 340  6
                                 match(SEMI);
 341  6
                                 importDefinition_AST = (AST)currentAST.root;
 342  6
                                 break;
 343  
                         }
 344  
                         default:
 345  
                         {
 346  0
                                 throw new NoViableAltException(LT(1), getFilename());
 347  
                         }
 348  
                         }
 349  
                 }
 350  0
                 catch (RecognitionException ex) {
 351  0
                         if (inputState.guessing==0) {
 352  0
                                 reportError(ex);
 353  0
                                 recover(ex,_tokenSet_0);
 354  
                         } else {
 355  0
                           throw ex;
 356  
                         }
 357  3428
                 }
 358  3428
                 returnAST = importDefinition_AST;
 359  3428
         }
 360  
         
 361  
         public final void typeDefinition() throws RecognitionException, TokenStreamException {
 362  
                 
 363  4349
                 returnAST = null;
 364  4349
                 ASTPair currentAST = new ASTPair();
 365  4349
                 AST typeDefinition_AST = null;
 366  4349
                 AST m_AST = null;
 367  
                 
 368  
                 try {      // for error handling
 369  4349
                         switch ( LA(1)) {
 370  
                         case FINAL:
 371  
                         case ABSTRACT:
 372  
                         case STRICTFP:
 373  
                         case LITERAL_private:
 374  
                         case LITERAL_public:
 375  
                         case LITERAL_protected:
 376  
                         case LITERAL_static:
 377  
                         case LITERAL_transient:
 378  
                         case LITERAL_native:
 379  
                         case LITERAL_synchronized:
 380  
                         case LITERAL_volatile:
 381  
                         case LITERAL_class:
 382  
                         case LITERAL_interface:
 383  
                         case LITERAL_default:
 384  
                         case ENUM:
 385  
                         case AT:
 386  
                         {
 387  4347
                                 modifiers();
 388  4347
                                 m_AST = (AST)returnAST;
 389  4347
                                 typeDefinitionInternal(m_AST);
 390  4343
                                 astFactory.addASTChild(currentAST, returnAST);
 391  4343
                                 typeDefinition_AST = (AST)currentAST.root;
 392  4343
                                 break;
 393  
                         }
 394  
                         case SEMI:
 395  
                         {
 396  2
                                 AST tmp6_AST = null;
 397  2
                                 tmp6_AST = astFactory.create(LT(1));
 398  2
                                 astFactory.addASTChild(currentAST, tmp6_AST);
 399  2
                                 match(SEMI);
 400  2
                                 typeDefinition_AST = (AST)currentAST.root;
 401  2
                                 break;
 402  
                         }
 403  
                         default:
 404  
                         {
 405  0
                                 throw new NoViableAltException(LT(1), getFilename());
 406  
                         }
 407  
                         }
 408  
                 }
 409  0
                 catch (RecognitionException ex) {
 410  0
                         if (inputState.guessing==0) {
 411  0
                                 reportError(ex);
 412  0
                                 recover(ex,_tokenSet_3);
 413  
                         } else {
 414  0
                           throw ex;
 415  
                         }
 416  4345
                 }
 417  4345
                 returnAST = typeDefinition_AST;
 418  4345
         }
 419  
         
 420  
         public final void identifier() throws RecognitionException, TokenStreamException {
 421  
                 
 422  6812
                 returnAST = null;
 423  6812
                 ASTPair currentAST = new ASTPair();
 424  6812
                 AST identifier_AST = null;
 425  
                 
 426  6812
                 AST tmp7_AST = null;
 427  6812
                 tmp7_AST = astFactory.create(LT(1));
 428  6812
                 astFactory.addASTChild(currentAST, tmp7_AST);
 429  6812
                 match(IDENT);
 430  
                 {
 431  
                 _loop54:
 432  
                 do {
 433  20538
                         if ((LA(1)==DOT)) {
 434  13726
                                 AST tmp8_AST = null;
 435  13726
                                 tmp8_AST = astFactory.create(LT(1));
 436  13726
                                 astFactory.makeASTRoot(currentAST, tmp8_AST);
 437  13726
                                 match(DOT);
 438  13726
                                 AST tmp9_AST = null;
 439  13726
                                 tmp9_AST = astFactory.create(LT(1));
 440  13726
                                 astFactory.addASTChild(currentAST, tmp9_AST);
 441  13726
                                 match(IDENT);
 442  13726
                         }
 443  
                         else {
 444  
                                 break _loop54;
 445  
                         }
 446  
                         
 447  
                 } while (true);
 448  
                 }
 449  6812
                 identifier_AST = (AST)currentAST.root;
 450  6812
                 returnAST = identifier_AST;
 451  6812
         }
 452  
         
 453  
         public final void identifierStar() throws RecognitionException, TokenStreamException {
 454  
                 
 455  3422
                 returnAST = null;
 456  3422
                 ASTPair currentAST = new ASTPair();
 457  3422
                 AST identifierStar_AST = null;
 458  
                 
 459  3422
                 AST tmp10_AST = null;
 460  3422
                 tmp10_AST = astFactory.create(LT(1));
 461  3422
                 astFactory.addASTChild(currentAST, tmp10_AST);
 462  3422
                 match(IDENT);
 463  
                 {
 464  
                 _loop57:
 465  
                 do {
 466  12442
                         if ((LA(1)==DOT) && (LA(2)==IDENT)) {
 467  9020
                                 AST tmp11_AST = null;
 468  9020
                                 tmp11_AST = astFactory.create(LT(1));
 469  9020
                                 astFactory.makeASTRoot(currentAST, tmp11_AST);
 470  9020
                                 match(DOT);
 471  9020
                                 AST tmp12_AST = null;
 472  9020
                                 tmp12_AST = astFactory.create(LT(1));
 473  9020
                                 astFactory.addASTChild(currentAST, tmp12_AST);
 474  9020
                                 match(IDENT);
 475  9020
                         }
 476  
                         else {
 477  
                                 break _loop57;
 478  
                         }
 479  
                         
 480  
                 } while (true);
 481  
                 }
 482  
                 {
 483  3422
                 switch ( LA(1)) {
 484  
                 case DOT:
 485  
                 {
 486  493
                         AST tmp13_AST = null;
 487  493
                         tmp13_AST = astFactory.create(LT(1));
 488  493
                         astFactory.makeASTRoot(currentAST, tmp13_AST);
 489  493
                         match(DOT);
 490  493
                         AST tmp14_AST = null;
 491  493
                         tmp14_AST = astFactory.create(LT(1));
 492  493
                         astFactory.addASTChild(currentAST, tmp14_AST);
 493  493
                         match(STAR);
 494  493
                         break;
 495  
                 }
 496  
                 case SEMI:
 497  
                 {
 498  2929
                         break;
 499  
                 }
 500  
                 default:
 501  
                 {
 502  0
                         throw new NoViableAltException(LT(1), getFilename());
 503  
                 }
 504  
                 }
 505  
                 }
 506  3422
                 identifierStar_AST = (AST)currentAST.root;
 507  3422
                 returnAST = identifierStar_AST;
 508  3422
         }
 509  
         
 510  
         public final void modifiers() throws RecognitionException, TokenStreamException {
 511  
                 
 512  47295
                 returnAST = null;
 513  47295
                 ASTPair currentAST = new ASTPair();
 514  47295
                 AST modifiers_AST = null;
 515  
                 
 516  
                 {
 517  
                 _loop61:
 518  
                 do {
 519  72307
                         if ((_tokenSet_4.member(LA(1)))) {
 520  22253
                                 modifier();
 521  22253
                                 astFactory.addASTChild(currentAST, returnAST);
 522  
                         }
 523  50054
                         else if (((LA(1)==AT) && (LA(2)==IDENT))&&(LA(1)==AT && !LT(2).getText().equals("interface"))) {
 524  2759
                                 annotation();
 525  2759
                                 astFactory.addASTChild(currentAST, returnAST);
 526  
                         }
 527  
                         else {
 528  
                                 break _loop61;
 529  
                         }
 530  
                         
 531  
                 } while (true);
 532  
                 }
 533  47295
                 if ( inputState.guessing==0 ) {
 534  34133
                         modifiers_AST = (AST)currentAST.root;
 535  34133
                         modifiers_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(MODIFIERS,"MODIFIERS")).add(modifiers_AST));
 536  34133
                         currentAST.root = modifiers_AST;
 537  34133
                         currentAST.child = modifiers_AST!=null &&modifiers_AST.getFirstChild()!=null ?
 538  18425
                                 modifiers_AST.getFirstChild() : modifiers_AST;
 539  34133
                         currentAST.advanceChildToEnd();
 540  
                 }
 541  47295
                 modifiers_AST = (AST)currentAST.root;
 542  47295
                 returnAST = modifiers_AST;
 543  47295
         }
 544  
         
 545  
         protected final void typeDefinitionInternal(
 546  
                 AST modifiers
 547  
         ) throws RecognitionException, TokenStreamException {
 548  
                 
 549  6615
                 returnAST = null;
 550  6615
                 ASTPair currentAST = new ASTPair();
 551  6615
                 AST typeDefinitionInternal_AST = null;
 552  
                 
 553  6615
                 switch ( LA(1)) {
 554  
                 case LITERAL_class:
 555  
                 {
 556  4921
                         classDefinition(modifiers);
 557  4917
                         astFactory.addASTChild(currentAST, returnAST);
 558  4917
                         typeDefinitionInternal_AST = (AST)currentAST.root;
 559  4917
                         break;
 560  
                 }
 561  
                 case LITERAL_interface:
 562  
                 {
 563  640
                         interfaceDefinition(modifiers);
 564  640
                         astFactory.addASTChild(currentAST, returnAST);
 565  640
                         typeDefinitionInternal_AST = (AST)currentAST.root;
 566  640
                         break;
 567  
                 }
 568  
                 case ENUM:
 569  
                 {
 570  463
                         enumDefinition(modifiers);
 571  463
                         astFactory.addASTChild(currentAST, returnAST);
 572  463
                         typeDefinitionInternal_AST = (AST)currentAST.root;
 573  463
                         break;
 574  
                 }
 575  
                 case AT:
 576  
                 {
 577  591
                         annotationDefinition(modifiers);
 578  591
                         astFactory.addASTChild(currentAST, returnAST);
 579  591
                         typeDefinitionInternal_AST = (AST)currentAST.root;
 580  591
                         break;
 581  
                 }
 582  
                 default:
 583  
                 {
 584  0
                         throw new NoViableAltException(LT(1), getFilename());
 585  
                 }
 586  
                 }
 587  6611
                 returnAST = typeDefinitionInternal_AST;
 588  6611
         }
 589  
         
 590  
         public final void classDefinition(
 591  
                 AST modifiers
 592  
         ) throws RecognitionException, TokenStreamException {
 593  
                 
 594  4984
                 returnAST = null;
 595  4984
                 ASTPair currentAST = new ASTPair();
 596  4984
                 AST classDefinition_AST = null;
 597  4984
                 Token  c = null;
 598  4984
                 AST c_AST = null;
 599  4984
                 AST tp_AST = null;
 600  4984
                 AST sc_AST = null;
 601  4984
                 AST ic_AST = null;
 602  4984
                 AST cb_AST = null;
 603  
                 
 604  4984
                 c = LT(1);
 605  4984
                 c_AST = astFactory.create(c);
 606  4984
                 match(LITERAL_class);
 607  4984
                 AST tmp15_AST = null;
 608  4984
                 tmp15_AST = astFactory.create(LT(1));
 609  4984
                 match(IDENT);
 610  
                 {
 611  4984
                 switch ( LA(1)) {
 612  
                 case LT:
 613  
                 {
 614  217
                         typeParameters();
 615  217
                         tp_AST = (AST)returnAST;
 616  217
                         break;
 617  
                 }
 618  
                 case LITERAL_extends:
 619  
                 case LCURLY:
 620  
                 case LITERAL_implements:
 621  
                 {
 622  4763
                         break;
 623  
                 }
 624  
                 default:
 625  
                 {
 626  0
                         throw new NoViableAltException(LT(1), getFilename());
 627  
                 }
 628  
                 }
 629  
                 }
 630  4980
                 superClassClause();
 631  4980
                 sc_AST = (AST)returnAST;
 632  4980
                 implementsClause();
 633  4980
                 ic_AST = (AST)returnAST;
 634  4980
                 classBlock();
 635  4980
                 cb_AST = (AST)returnAST;
 636  4980
                 if ( inputState.guessing==0 ) {
 637  4980
                         classDefinition_AST = (AST)currentAST.root;
 638  4980
                         classDefinition_AST = (AST)astFactory.make( (new ASTArray(8)).add(astFactory.create(CLASS_DEF,"CLASS_DEF")).add(modifiers).add(c_AST).add(tmp15_AST).add(tp_AST).add(sc_AST).add(ic_AST).add(cb_AST));
 639  4980
                         currentAST.root = classDefinition_AST;
 640  4980
                         currentAST.child = classDefinition_AST!=null &&classDefinition_AST.getFirstChild()!=null ?
 641  4980
                                 classDefinition_AST.getFirstChild() : classDefinition_AST;
 642  4980
                         currentAST.advanceChildToEnd();
 643  
                 }
 644  4980
                 returnAST = classDefinition_AST;
 645  4980
         }
 646  
         
 647  
         public final void interfaceDefinition(
 648  
                 AST modifiers
 649  
         ) throws RecognitionException, TokenStreamException {
 650  
                 
 651  640
                 returnAST = null;
 652  640
                 ASTPair currentAST = new ASTPair();
 653  640
                 AST interfaceDefinition_AST = null;
 654  640
                 Token  i = null;
 655  640
                 AST i_AST = null;
 656  640
                 AST tp_AST = null;
 657  640
                 AST ie_AST = null;
 658  640
                 AST cb_AST = null;
 659  
                 
 660  640
                 i = LT(1);
 661  640
                 i_AST = astFactory.create(i);
 662  640
                 match(LITERAL_interface);
 663  640
                 AST tmp16_AST = null;
 664  640
                 tmp16_AST = astFactory.create(LT(1));
 665  640
                 match(IDENT);
 666  
                 {
 667  640
                 switch ( LA(1)) {
 668  
                 case LT:
 669  
                 {
 670  54
                         typeParameters();
 671  54
                         tp_AST = (AST)returnAST;
 672  54
                         break;
 673  
                 }
 674  
                 case LITERAL_extends:
 675  
                 case LCURLY:
 676  
                 {
 677  586
                         break;
 678  
                 }
 679  
                 default:
 680  
                 {
 681  0
                         throw new NoViableAltException(LT(1), getFilename());
 682  
                 }
 683  
                 }
 684  
                 }
 685  640
                 interfaceExtends();
 686  640
                 ie_AST = (AST)returnAST;
 687  640
                 classBlock();
 688  640
                 cb_AST = (AST)returnAST;
 689  640
                 if ( inputState.guessing==0 ) {
 690  640
                         interfaceDefinition_AST = (AST)currentAST.root;
 691  640
                         interfaceDefinition_AST = (AST)astFactory.make( (new ASTArray(7)).add(astFactory.create(INTERFACE_DEF,"INTERFACE_DEF")).add(modifiers).add(i_AST).add(tmp16_AST).add(tp_AST).add(ie_AST).add(cb_AST));
 692  640
                         currentAST.root = interfaceDefinition_AST;
 693  640
                         currentAST.child = interfaceDefinition_AST!=null &&interfaceDefinition_AST.getFirstChild()!=null ?
 694  640
                                 interfaceDefinition_AST.getFirstChild() : interfaceDefinition_AST;
 695  640
                         currentAST.advanceChildToEnd();
 696  
                 }
 697  640
                 returnAST = interfaceDefinition_AST;
 698  640
         }
 699  
         
 700  
         public final void enumDefinition(
 701  
                 AST modifiers
 702  
         ) throws RecognitionException, TokenStreamException {
 703  
                 
 704  463
                 returnAST = null;
 705  463
                 ASTPair currentAST = new ASTPair();
 706  463
                 AST enumDefinition_AST = null;
 707  463
                 Token  e = null;
 708  463
                 AST e_AST = null;
 709  463
                 AST ic_AST = null;
 710  463
                 AST eb_AST = null;
 711  
                 
 712  463
                 e = LT(1);
 713  463
                 e_AST = astFactory.create(e);
 714  463
                 match(ENUM);
 715  463
                 AST tmp17_AST = null;
 716  463
                 tmp17_AST = astFactory.create(LT(1));
 717  463
                 match(IDENT);
 718  463
                 implementsClause();
 719  463
                 ic_AST = (AST)returnAST;
 720  463
                 enumBlock();
 721  463
                 eb_AST = (AST)returnAST;
 722  463
                 if ( inputState.guessing==0 ) {
 723  463
                         enumDefinition_AST = (AST)currentAST.root;
 724  463
                         enumDefinition_AST = (AST)astFactory.make( (new ASTArray(6)).add(astFactory.create(ENUM_DEF,"ENUM_DEF")).add(modifiers).add(e_AST).add(tmp17_AST).add(ic_AST).add(eb_AST));
 725  463
                         currentAST.root = enumDefinition_AST;
 726  463
                         currentAST.child = enumDefinition_AST!=null &&enumDefinition_AST.getFirstChild()!=null ?
 727  463
                                 enumDefinition_AST.getFirstChild() : enumDefinition_AST;
 728  463
                         currentAST.advanceChildToEnd();
 729  
                 }
 730  463
                 returnAST = enumDefinition_AST;
 731  463
         }
 732  
         
 733  
         public final void annotationDefinition(
 734  
                 AST modifiers
 735  
         ) throws RecognitionException, TokenStreamException {
 736  
                 
 737  591
                 returnAST = null;
 738  591
                 ASTPair currentAST = new ASTPair();
 739  591
                 AST annotationDefinition_AST = null;
 740  591
                 Token  a = null;
 741  591
                 AST a_AST = null;
 742  591
                 Token  i = null;
 743  591
                 AST i_AST = null;
 744  591
                 AST ab_AST = null;
 745  
                 
 746  591
                 a = LT(1);
 747  591
                 a_AST = astFactory.create(a);
 748  591
                 match(AT);
 749  591
                 i = LT(1);
 750  591
                 i_AST = astFactory.create(i);
 751  591
                 match(LITERAL_interface);
 752  591
                 AST tmp18_AST = null;
 753  591
                 tmp18_AST = astFactory.create(LT(1));
 754  591
                 match(IDENT);
 755  591
                 annotationBlock();
 756  591
                 ab_AST = (AST)returnAST;
 757  591
                 if ( inputState.guessing==0 ) {
 758  591
                         annotationDefinition_AST = (AST)currentAST.root;
 759  591
                         annotationDefinition_AST = (AST)astFactory.make( (new ASTArray(6)).add(astFactory.create(ANNOTATION_DEF,"ANNOTATION_DEF")).add(modifiers).add(a_AST).add(i_AST).add(tmp18_AST).add(ab_AST));
 760  591
                         currentAST.root = annotationDefinition_AST;
 761  591
                         currentAST.child = annotationDefinition_AST!=null &&annotationDefinition_AST.getFirstChild()!=null ?
 762  591
                                 annotationDefinition_AST.getFirstChild() : annotationDefinition_AST;
 763  591
                         currentAST.advanceChildToEnd();
 764  
                 }
 765  591
                 returnAST = annotationDefinition_AST;
 766  591
         }
 767  
         
 768  
         public final void typeSpec(
 769  
                 boolean addImagNode
 770  
         ) throws RecognitionException, TokenStreamException {
 771  
                 
 772  87640
                 returnAST = null;
 773  87640
                 ASTPair currentAST = new ASTPair();
 774  87640
                 AST typeSpec_AST = null;
 775  
                 
 776  87640
                 switch ( LA(1)) {
 777  
                 case IDENT:
 778  
                 case AT:
 779  
                 {
 780  55446
                         classTypeSpec(addImagNode);
 781  55169
                         astFactory.addASTChild(currentAST, returnAST);
 782  55169
                         typeSpec_AST = (AST)currentAST.root;
 783  55169
                         break;
 784  
                 }
 785  
                 case LITERAL_void:
 786  
                 case LITERAL_boolean:
 787  
                 case LITERAL_byte:
 788  
                 case LITERAL_char:
 789  
                 case LITERAL_short:
 790  
                 case LITERAL_int:
 791  
                 case LITERAL_float:
 792  
                 case LITERAL_long:
 793  
                 case LITERAL_double:
 794  
                 {
 795  32192
                         builtInTypeSpec(addImagNode);
 796  32192
                         astFactory.addASTChild(currentAST, returnAST);
 797  32192
                         typeSpec_AST = (AST)currentAST.root;
 798  32192
                         break;
 799  
                 }
 800  
                 default:
 801  
                 {
 802  2
                         throw new NoViableAltException(LT(1), getFilename());
 803  
                 }
 804  
                 }
 805  87361
                 returnAST = typeSpec_AST;
 806  87361
         }
 807  
         
 808  
         public final void classTypeSpec(
 809  
                 boolean addImagNode
 810  
         ) throws RecognitionException, TokenStreamException {
 811  
                 
 812  60589
                 returnAST = null;
 813  60589
                 ASTPair currentAST = new ASTPair();
 814  60589
                 AST classTypeSpec_AST = null;
 815  60589
                 Token  lb = null;
 816  60589
                 AST lb_AST = null;
 817  
                 
 818  60589
                 classOrInterfaceType(addImagNode);
 819  60479
                 astFactory.addASTChild(currentAST, returnAST);
 820  
                 {
 821  
                 _loop18:
 822  
                 do {
 823  61951
                         if ((LA(1)==LBRACK||LA(1)==AT) && (LA(2)==RBRACK||LA(2)==IDENT)) {
 824  
                                 {
 825  1685
                                 if (((LA(1)==LBRACK||LA(1)==AT) && (LA(2)==RBRACK||LA(2)==IDENT))&&(LA(1) == AT)) {
 826  16
                                         annotations();
 827  16
                                         astFactory.addASTChild(currentAST, returnAST);
 828  
                                 }
 829  1669
                                 else if ((LA(1)==LBRACK) && (LA(2)==RBRACK)) {
 830  
                                 }
 831  
                                 else {
 832  213
                                         throw new NoViableAltException(LT(1), getFilename());
 833  
                                 }
 834  
                                 
 835  
                                 }
 836  1472
                                 lb = LT(1);
 837  1472
                                 lb_AST = astFactory.create(lb);
 838  1472
                                 astFactory.makeASTRoot(currentAST, lb_AST);
 839  1472
                                 match(LBRACK);
 840  1472
                                 if ( inputState.guessing==0 ) {
 841  786
                                         lb_AST.setType(ARRAY_DECLARATOR);
 842  
                                 }
 843  1472
                                 AST tmp19_AST = null;
 844  1472
                                 tmp19_AST = astFactory.create(LT(1));
 845  1472
                                 astFactory.addASTChild(currentAST, tmp19_AST);
 846  1472
                                 match(RBRACK);
 847  1472
                         }
 848  
                         else {
 849  
                                 break _loop18;
 850  
                         }
 851  
                         
 852  
                 } while (true);
 853  
                 }
 854  60266
                 if ( inputState.guessing==0 ) {
 855  13214
                         classTypeSpec_AST = (AST)currentAST.root;
 856  
                         
 857  13214
                         if ( addImagNode ) {
 858  751
                         classTypeSpec_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(TYPE,"TYPE")).add(classTypeSpec_AST));
 859  
                         }
 860  
                         
 861  13214
                         currentAST.root = classTypeSpec_AST;
 862  13214
                         currentAST.child = classTypeSpec_AST!=null &&classTypeSpec_AST.getFirstChild()!=null ?
 863  1926
                                 classTypeSpec_AST.getFirstChild() : classTypeSpec_AST;
 864  13214
                         currentAST.advanceChildToEnd();
 865  
                 }
 866  60266
                 classTypeSpec_AST = (AST)currentAST.root;
 867  60266
                 returnAST = classTypeSpec_AST;
 868  60266
         }
 869  
         
 870  
         public final void builtInTypeSpec(
 871  
                 boolean addImagNode
 872  
         ) throws RecognitionException, TokenStreamException {
 873  
                 
 874  32602
                 returnAST = null;
 875  32602
                 ASTPair currentAST = new ASTPair();
 876  32602
                 AST builtInTypeSpec_AST = null;
 877  32602
                 Token  lb = null;
 878  32602
                 AST lb_AST = null;
 879  
                 
 880  32602
                 builtInType();
 881  32602
                 astFactory.addASTChild(currentAST, returnAST);
 882  
                 {
 883  
                 _loop48:
 884  
                 do {
 885  33416
                         if ((LA(1)==LBRACK||LA(1)==AT) && (LA(2)==RBRACK||LA(2)==IDENT)) {
 886  
                                 {
 887  814
                                 if (((LA(1)==LBRACK||LA(1)==AT) && (LA(2)==RBRACK||LA(2)==IDENT))&&(LA(1) == AT)) {
 888  16
                                         annotations();
 889  16
                                         astFactory.addASTChild(currentAST, returnAST);
 890  
                                 }
 891  798
                                 else if ((LA(1)==LBRACK) && (LA(2)==RBRACK)) {
 892  
                                 }
 893  
                                 else {
 894  0
                                         throw new NoViableAltException(LT(1), getFilename());
 895  
                                 }
 896  
                                 
 897  
                                 }
 898  814
                                 lb = LT(1);
 899  814
                                 lb_AST = astFactory.create(lb);
 900  814
                                 astFactory.makeASTRoot(currentAST, lb_AST);
 901  814
                                 match(LBRACK);
 902  814
                                 if ( inputState.guessing==0 ) {
 903  570
                                         lb_AST.setType(ARRAY_DECLARATOR);
 904  
                                 }
 905  814
                                 AST tmp20_AST = null;
 906  814
                                 tmp20_AST = astFactory.create(LT(1));
 907  814
                                 astFactory.addASTChild(currentAST, tmp20_AST);
 908  814
                                 match(RBRACK);
 909  814
                         }
 910  
                         else {
 911  
                                 break _loop48;
 912  
                         }
 913  
                         
 914  
                 } while (true);
 915  
                 }
 916  32602
                 if ( inputState.guessing==0 ) {
 917  22430
                         builtInTypeSpec_AST = (AST)currentAST.root;
 918  
                         
 919  22430
                         if ( addImagNode ) {
 920  140
                         builtInTypeSpec_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(TYPE,"TYPE")).add(builtInTypeSpec_AST));
 921  
                         }
 922  
                         
 923  22430
                         currentAST.root = builtInTypeSpec_AST;
 924  22430
                         currentAST.child = builtInTypeSpec_AST!=null &&builtInTypeSpec_AST.getFirstChild()!=null ?
 925  642
                                 builtInTypeSpec_AST.getFirstChild() : builtInTypeSpec_AST;
 926  22430
                         currentAST.advanceChildToEnd();
 927  
                 }
 928  32602
                 builtInTypeSpec_AST = (AST)currentAST.root;
 929  32602
                 returnAST = builtInTypeSpec_AST;
 930  32602
         }
 931  
         
 932  
         public final void classOrInterfaceType(
 933  
                 boolean addImagNode
 934  
         ) throws RecognitionException, TokenStreamException {
 935  
                 
 936  66367
                 returnAST = null;
 937  66367
                 ASTPair currentAST = new ASTPair();
 938  66367
                 AST classOrInterfaceType_AST = null;
 939  
                 
 940  
                 {
 941  66367
                 if (((LA(1)==IDENT||LA(1)==AT) && (_tokenSet_5.member(LA(2))))&&(LA(1) == AT)) {
 942  141
                         annotations();
 943  141
                         astFactory.addASTChild(currentAST, returnAST);
 944  
                 }
 945  66226
                 else if ((LA(1)==IDENT) && (_tokenSet_5.member(LA(2)))) {
 946  
                 }
 947  
                 else {
 948  46
                         throw new NoViableAltException(LT(1), getFilename());
 949  
                 }
 950  
                 
 951  
                 }
 952  66321
                 AST tmp21_AST = null;
 953  66321
                 tmp21_AST = astFactory.create(LT(1));
 954  66321
                 astFactory.addASTChild(currentAST, tmp21_AST);
 955  66321
                 match(IDENT);
 956  
                 {
 957  66257
                 if ((LA(1)==LT) && (_tokenSet_5.member(LA(2)))) {
 958  3200
                         typeArguments(addImagNode);
 959  3200
                         astFactory.addASTChild(currentAST, returnAST);
 960  
                 }
 961  63057
                 else if ((_tokenSet_5.member(LA(1))) && (_tokenSet_6.member(LA(2)))) {
 962  
                 }
 963  
                 else {
 964  0
                         throw new NoViableAltException(LT(1), getFilename());
 965  
                 }
 966  
                 
 967  
                 }
 968  
                 {
 969  
                 _loop25:
 970  
                 do {
 971  84983
                         if ((LA(1)==DOT) && (LA(2)==IDENT||LA(2)==AT)) {
 972  18726
                                 AST tmp22_AST = null;
 973  18726
                                 tmp22_AST = astFactory.create(LT(1));
 974  18726
                                 astFactory.makeASTRoot(currentAST, tmp22_AST);
 975  18726
                                 match(DOT);
 976  
                                 {
 977  18726
                                 if (((LA(1)==IDENT||LA(1)==AT) && (_tokenSet_5.member(LA(2))))&&(LA(1) == AT)) {
 978  23
                                         annotations();
 979  23
                                         astFactory.addASTChild(currentAST, returnAST);
 980  
                                 }
 981  18703
                                 else if ((LA(1)==IDENT) && (_tokenSet_5.member(LA(2)))) {
 982  
                                 }
 983  
                                 else {
 984  0
                                         throw new NoViableAltException(LT(1), getFilename());
 985  
                                 }
 986  
                                 
 987  
                                 }
 988  18726
                                 AST tmp23_AST = null;
 989  18726
                                 tmp23_AST = astFactory.create(LT(1));
 990  18726
                                 astFactory.addASTChild(currentAST, tmp23_AST);
 991  18726
                                 match(IDENT);
 992  
                                 {
 993  18726
                                 if ((LA(1)==LT) && (_tokenSet_5.member(LA(2)))) {
 994  449
                                         typeArguments(addImagNode);
 995  449
                                         astFactory.addASTChild(currentAST, returnAST);
 996  
                                 }
 997  18277
                                 else if ((_tokenSet_5.member(LA(1))) && (_tokenSet_6.member(LA(2)))) {
 998  
                                 }
 999  
                                 else {
 1000  0
                                         throw new NoViableAltException(LT(1), getFilename());
 1001  
                                 }
 1002  
                                 
 1003  
                                 }
 1004  18726
                         }
 1005  
                         else {
 1006  
                                 break _loop25;
 1007  
                         }
 1008  
                         
 1009  
                 } while (true);
 1010  
                 }
 1011  66257
                 classOrInterfaceType_AST = (AST)currentAST.root;
 1012  66257
                 returnAST = classOrInterfaceType_AST;
 1013  66257
         }
 1014  
         
 1015  
         public final void typeArguments(
 1016  
                 boolean addImagNode
 1017  
         ) throws RecognitionException, TokenStreamException {
 1018  
                 
 1019  3751
                 returnAST = null;
 1020  3751
                 ASTPair currentAST = new ASTPair();
 1021  3751
                 AST typeArguments_AST = null;
 1022  3751
                 Token  lt = null;
 1023  3751
                 AST lt_AST = null;
 1024  3751
                 int currentLtLevel = 0;
 1025  
                 
 1026  3751
                 if ( inputState.guessing==0 ) {
 1027  1621
                         currentLtLevel = ltCounter;
 1028  
                 }
 1029  3751
                 lt = LT(1);
 1030  3751
                 lt_AST = astFactory.create(lt);
 1031  3751
                 astFactory.addASTChild(currentAST, lt_AST);
 1032  3751
                 match(LT);
 1033  3751
                 if ( inputState.guessing==0 ) {
 1034  1621
                         lt_AST.setType(GENERIC_START); ;ltCounter++;
 1035  
                 }
 1036  
                 {
 1037  3751
                 if ((_tokenSet_7.member(LA(1))) && (_tokenSet_5.member(LA(2)))) {
 1038  2761
                         typeArgument(addImagNode);
 1039  2761
                         astFactory.addASTChild(currentAST, returnAST);
 1040  
                         {
 1041  
                         _loop37:
 1042  
                         do {
 1043  3687
                                 if (((LA(1)==COMMA) && (_tokenSet_7.member(LA(2))))&&(gtToReconcile == 0)) {
 1044  926
                                         AST tmp24_AST = null;
 1045  926
                                         tmp24_AST = astFactory.create(LT(1));
 1046  926
                                         astFactory.addASTChild(currentAST, tmp24_AST);
 1047  926
                                         match(COMMA);
 1048  926
                                         typeArgument(addImagNode);
 1049  926
                                         astFactory.addASTChild(currentAST, returnAST);
 1050  926
                                 }
 1051  
                                 else {
 1052  
                                         break _loop37;
 1053  
                                 }
 1054  
                                 
 1055  
                         } while (true);
 1056  
                         }
 1057  
                 }
 1058  990
                 else if ((_tokenSet_5.member(LA(1))) && (_tokenSet_6.member(LA(2)))) {
 1059  
                 }
 1060  
                 else {
 1061  0
                         throw new NoViableAltException(LT(1), getFilename());
 1062  
                 }
 1063  
                 
 1064  
                 }
 1065  
                 {
 1066  3751
                 if ((_tokenSet_8.member(LA(1))) && (_tokenSet_5.member(LA(2)))) {
 1067  2574
                         typeArgumentsOrParametersEnd();
 1068  2574
                         astFactory.addASTChild(currentAST, returnAST);
 1069  
                 }
 1070  1177
                 else if ((_tokenSet_5.member(LA(1))) && (_tokenSet_6.member(LA(2)))) {
 1071  
                 }
 1072  
                 else {
 1073  0
                         throw new NoViableAltException(LT(1), getFilename());
 1074  
                 }
 1075  
                 
 1076  
                 }
 1077  3751
                 if ( inputState.guessing==0 ) {
 1078  
                         
 1079  1621
                         if (areThereGtsToEmit())
 1080  
                         {
 1081  1621
                         astFactory.addASTChild(currentAST, emitSingleGt());
 1082  
                         }
 1083  
                         
 1084  
                 }
 1085  3751
                 if (!(areLtsAndGtsBalanced(currentLtLevel)))
 1086  0
                   throw new SemanticException("areLtsAndGtsBalanced(currentLtLevel)");
 1087  3751
                 if ( inputState.guessing==0 ) {
 1088  1621
                         typeArguments_AST = (AST)currentAST.root;
 1089  1621
                         typeArguments_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(TYPE_ARGUMENTS,"TYPE_ARGUMENTS")).add(typeArguments_AST));
 1090  1621
                         currentAST.root = typeArguments_AST;
 1091  1621
                         currentAST.child = typeArguments_AST!=null &&typeArguments_AST.getFirstChild()!=null ?
 1092  1621
                                 typeArguments_AST.getFirstChild() : typeArguments_AST;
 1093  1621
                         currentAST.advanceChildToEnd();
 1094  
                 }
 1095  3751
                 typeArguments_AST = (AST)currentAST.root;
 1096  3751
                 returnAST = typeArguments_AST;
 1097  3751
         }
 1098  
         
 1099  
         public final void typeArgument(
 1100  
                 boolean addImagNode
 1101  
         ) throws RecognitionException, TokenStreamException {
 1102  
                 
 1103  3687
                 returnAST = null;
 1104  3687
                 ASTPair currentAST = new ASTPair();
 1105  3687
                 AST typeArgument_AST = null;
 1106  
                 
 1107  
                 {
 1108  
                 {
 1109  3687
                 if (((_tokenSet_7.member(LA(1))) && (_tokenSet_5.member(LA(2))))&&(LA(1) == AT)) {
 1110  51
                         annotations();
 1111  51
                         astFactory.addASTChild(currentAST, returnAST);
 1112  
                 }
 1113  3636
                 else if ((_tokenSet_7.member(LA(1))) && (_tokenSet_5.member(LA(2)))) {
 1114  
                 }
 1115  
                 else {
 1116  0
                         throw new NoViableAltException(LT(1), getFilename());
 1117  
                 }
 1118  
                 
 1119  
                 }
 1120  
                 {
 1121  3687
                 switch ( LA(1)) {
 1122  
                 case IDENT:
 1123  
                 case AT:
 1124  
                 {
 1125  3345
                         classTypeSpec(addImagNode);
 1126  3345
                         astFactory.addASTChild(currentAST, returnAST);
 1127  3345
                         break;
 1128  
                 }
 1129  
                 case LITERAL_void:
 1130  
                 case LITERAL_boolean:
 1131  
                 case LITERAL_byte:
 1132  
                 case LITERAL_char:
 1133  
                 case LITERAL_short:
 1134  
                 case LITERAL_int:
 1135  
                 case LITERAL_float:
 1136  
                 case LITERAL_long:
 1137  
                 case LITERAL_double:
 1138  
                 {
 1139  10
                         builtInTypeSpec(addImagNode);
 1140  10
                         astFactory.addASTChild(currentAST, returnAST);
 1141  10
                         break;
 1142  
                 }
 1143  
                 case QUESTION:
 1144  
                 {
 1145  332
                         wildcardType(addImagNode);
 1146  332
                         astFactory.addASTChild(currentAST, returnAST);
 1147  332
                         break;
 1148  
                 }
 1149  
                 default:
 1150  
                 {
 1151  0
                         throw new NoViableAltException(LT(1), getFilename());
 1152  
                 }
 1153  
                 }
 1154  
                 }
 1155  
                 }
 1156  3687
                 if ( inputState.guessing==0 ) {
 1157  2051
                         typeArgument_AST = (AST)currentAST.root;
 1158  2051
                         typeArgument_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(TYPE_ARGUMENT,"TYPE_ARGUMENT")).add(typeArgument_AST));
 1159  2051
                         currentAST.root = typeArgument_AST;
 1160  2051
                         currentAST.child = typeArgument_AST!=null &&typeArgument_AST.getFirstChild()!=null ?
 1161  2051
                                 typeArgument_AST.getFirstChild() : typeArgument_AST;
 1162  2051
                         currentAST.advanceChildToEnd();
 1163  
                 }
 1164  3687
                 typeArgument_AST = (AST)currentAST.root;
 1165  3687
                 returnAST = typeArgument_AST;
 1166  3687
         }
 1167  
         
 1168  
         public final void wildcardType(
 1169  
                 boolean addImagNode
 1170  
         ) throws RecognitionException, TokenStreamException {
 1171  
                 
 1172  332
                 returnAST = null;
 1173  332
                 ASTPair currentAST = new ASTPair();
 1174  332
                 AST wildcardType_AST = null;
 1175  332
                 Token  q = null;
 1176  332
                 AST q_AST = null;
 1177  
                 
 1178  332
                 q = LT(1);
 1179  332
                 q_AST = astFactory.create(q);
 1180  332
                 astFactory.addASTChild(currentAST, q_AST);
 1181  332
                 match(QUESTION);
 1182  332
                 if ( inputState.guessing==0 ) {
 1183  181
                         q_AST.setType(WILDCARD_TYPE);
 1184  
                 }
 1185  
                 {
 1186  332
                 boolean synPredMatched33 = false;
 1187  332
                 if (((LA(1)==LITERAL_extends||LA(1)==LITERAL_super) && (_tokenSet_9.member(LA(2))))) {
 1188  168
                         int _m33 = mark();
 1189  168
                         synPredMatched33 = true;
 1190  168
                         inputState.guessing++;
 1191  
                         try {
 1192  
                                 {
 1193  168
                                 switch ( LA(1)) {
 1194  
                                 case LITERAL_extends:
 1195  
                                 {
 1196  99
                                         match(LITERAL_extends);
 1197  99
                                         break;
 1198  
                                 }
 1199  
                                 case LITERAL_super:
 1200  
                                 {
 1201  69
                                         match(LITERAL_super);
 1202  69
                                         break;
 1203  
                                 }
 1204  
                                 default:
 1205  
                                 {
 1206  0
                                         throw new NoViableAltException(LT(1), getFilename());
 1207  
                                 }
 1208  
                                 }
 1209  
                                 }
 1210  
                         }
 1211  0
                         catch (RecognitionException pe) {
 1212  0
                                 synPredMatched33 = false;
 1213  168
                         }
 1214  168
                         rewind(_m33);
 1215  168
 inputState.guessing--;
 1216  
                 }
 1217  332
                 if ( synPredMatched33 ) {
 1218  168
                         typeArgumentBounds(addImagNode);
 1219  168
                         astFactory.addASTChild(currentAST, returnAST);
 1220  
                 }
 1221  164
                 else if ((_tokenSet_5.member(LA(1))) && (_tokenSet_6.member(LA(2)))) {
 1222  
                 }
 1223  
                 else {
 1224  0
                         throw new NoViableAltException(LT(1), getFilename());
 1225  
                 }
 1226  
                 
 1227  
                 }
 1228  332
                 wildcardType_AST = (AST)currentAST.root;
 1229  332
                 returnAST = wildcardType_AST;
 1230  332
         }
 1231  
         
 1232  
         public final void typeArgumentBounds(
 1233  
                 boolean addImagNode
 1234  
         ) throws RecognitionException, TokenStreamException {
 1235  
                 
 1236  168
                 returnAST = null;
 1237  168
                 ASTPair currentAST = new ASTPair();
 1238  168
                 AST typeArgumentBounds_AST = null;
 1239  168
                 Token  e = null;
 1240  168
                 AST e_AST = null;
 1241  168
                 Token  s = null;
 1242  168
                 AST s_AST = null;
 1243  168
                 Token  lb = null;
 1244  168
                 AST lb_AST = null;
 1245  
                 
 1246  
                 {
 1247  168
                 switch ( LA(1)) {
 1248  
                 case LITERAL_extends:
 1249  
                 {
 1250  99
                         e = LT(1);
 1251  99
                         e_AST = astFactory.create(e);
 1252  99
                         astFactory.makeASTRoot(currentAST, e_AST);
 1253  99
                         match(LITERAL_extends);
 1254  99
                         if ( inputState.guessing==0 ) {
 1255  51
                                 e_AST.setType(TYPE_UPPER_BOUNDS);
 1256  
                         }
 1257  
                         break;
 1258  
                 }
 1259  
                 case LITERAL_super:
 1260  
                 {
 1261  69
                         s = LT(1);
 1262  69
                         s_AST = astFactory.create(s);
 1263  69
                         astFactory.makeASTRoot(currentAST, s_AST);
 1264  69
                         match(LITERAL_super);
 1265  69
                         if ( inputState.guessing==0 ) {
 1266  35
                                 s_AST.setType(TYPE_LOWER_BOUNDS);
 1267  
                         }
 1268  
                         break;
 1269  
                 }
 1270  
                 default:
 1271  
                 {
 1272  0
                         throw new NoViableAltException(LT(1), getFilename());
 1273  
                 }
 1274  
                 }
 1275  
                 }
 1276  
                 {
 1277  168
                 switch ( LA(1)) {
 1278  
                 case IDENT:
 1279  
                 case AT:
 1280  
                 {
 1281  160
                         classOrInterfaceType(addImagNode);
 1282  160
                         astFactory.addASTChild(currentAST, returnAST);
 1283  160
                         break;
 1284  
                 }
 1285  
                 case LITERAL_void:
 1286  
                 case LITERAL_boolean:
 1287  
                 case LITERAL_byte:
 1288  
                 case LITERAL_char:
 1289  
                 case LITERAL_short:
 1290  
                 case LITERAL_int:
 1291  
                 case LITERAL_float:
 1292  
                 case LITERAL_long:
 1293  
                 case LITERAL_double:
 1294  
                 {
 1295  8
                         builtInType();
 1296  8
                         astFactory.addASTChild(currentAST, returnAST);
 1297  8
                         break;
 1298  
                 }
 1299  
                 default:
 1300  
                 {
 1301  0
                         throw new NoViableAltException(LT(1), getFilename());
 1302  
                 }
 1303  
                 }
 1304  
                 }
 1305  
                 {
 1306  
                 _loop44:
 1307  
                 do {
 1308  300
                         if ((LA(1)==LBRACK) && (LA(2)==RBRACK)) {
 1309  132
                                 lb = LT(1);
 1310  132
                                 lb_AST = astFactory.create(lb);
 1311  132
                                 astFactory.makeASTRoot(currentAST, lb_AST);
 1312  132
                                 match(LBRACK);
 1313  132
                                 if ( inputState.guessing==0 ) {
 1314  68
                                         lb_AST.setType(ARRAY_DECLARATOR);
 1315  
                                 }
 1316  132
                                 AST tmp25_AST = null;
 1317  132
                                 tmp25_AST = astFactory.create(LT(1));
 1318  132
                                 astFactory.addASTChild(currentAST, tmp25_AST);
 1319  132
                                 match(RBRACK);
 1320  132
                         }
 1321  
                         else {
 1322  
                                 break _loop44;
 1323  
                         }
 1324  
                         
 1325  
                 } while (true);
 1326  
                 }
 1327  168
                 typeArgumentBounds_AST = (AST)currentAST.root;
 1328  168
                 returnAST = typeArgumentBounds_AST;
 1329  168
         }
 1330  
         
 1331  
         protected final void typeArgumentsOrParametersEnd() throws RecognitionException, TokenStreamException {
 1332  
                 
 1333  3168
                 returnAST = null;
 1334  3168
                 ASTPair currentAST = new ASTPair();
 1335  3168
                 AST typeArgumentsOrParametersEnd_AST = null;
 1336  3168
                 Token  g = null;
 1337  3168
                 AST g_AST = null;
 1338  3168
                 Token  sr = null;
 1339  3168
                 AST sr_AST = null;
 1340  3168
                 Token  bsr = null;
 1341  3168
                 AST bsr_AST = null;
 1342  
                 
 1343  3168
                 switch ( LA(1)) {
 1344  
                 case GT:
 1345  
                 {
 1346  2941
                         g = LT(1);
 1347  2941
                         g_AST = astFactory.create(g);
 1348  2941
                         match(GT);
 1349  2941
                         if ( inputState.guessing==0 ) {
 1350  1906
                                 consumeCurrentGtSequence((DetailAST)g_AST);
 1351  
                         }
 1352  
                         break;
 1353  
                 }
 1354  
                 case SR:
 1355  
                 {
 1356  171
                         sr = LT(1);
 1357  171
                         sr_AST = astFactory.create(sr);
 1358  171
                         match(SR);
 1359  171
                         if ( inputState.guessing==0 ) {
 1360  113
                                 consumeCurrentGtSequence((DetailAST)sr_AST);
 1361  
                         }
 1362  
                         break;
 1363  
                 }
 1364  
                 case BSR:
 1365  
                 {
 1366  56
                         bsr = LT(1);
 1367  56
                         bsr_AST = astFactory.create(bsr);
 1368  56
                         match(BSR);
 1369  56
                         if ( inputState.guessing==0 ) {
 1370  28
                                 consumeCurrentGtSequence((DetailAST)bsr_AST);
 1371  
                         }
 1372  
                         break;
 1373  
                 }
 1374  
                 default:
 1375  
                 {
 1376  0
                         throw new NoViableAltException(LT(1), getFilename());
 1377  
                 }
 1378  
                 }
 1379  3168
                 returnAST = typeArgumentsOrParametersEnd_AST;
 1380  3168
         }
 1381  
         
 1382  
         public final void builtInType() throws RecognitionException, TokenStreamException {
 1383  
                 
 1384  33264
                 returnAST = null;
 1385  33264
                 ASTPair currentAST = new ASTPair();
 1386  33264
                 AST builtInType_AST = null;
 1387  
                 
 1388  33264
                 switch ( LA(1)) {
 1389  
                 case LITERAL_void:
 1390  
                 {
 1391  8686
                         AST tmp26_AST = null;
 1392  8686
                         tmp26_AST = astFactory.create(LT(1));
 1393  8686
                         astFactory.addASTChild(currentAST, tmp26_AST);
 1394  8686
                         match(LITERAL_void);
 1395  8686
                         builtInType_AST = (AST)currentAST.root;
 1396  8686
                         break;
 1397  
                 }
 1398  
                 case LITERAL_boolean:
 1399  
                 {
 1400  2142
                         AST tmp27_AST = null;
 1401  2142
                         tmp27_AST = astFactory.create(LT(1));
 1402  2142
                         astFactory.addASTChild(currentAST, tmp27_AST);
 1403  2142
                         match(LITERAL_boolean);
 1404  2142
                         builtInType_AST = (AST)currentAST.root;
 1405  2142
                         break;
 1406  
                 }
 1407  
                 case LITERAL_byte:
 1408  
                 {
 1409  202
                         AST tmp28_AST = null;
 1410  202
                         tmp28_AST = astFactory.create(LT(1));
 1411  202
                         astFactory.addASTChild(currentAST, tmp28_AST);
 1412  202
                         match(LITERAL_byte);
 1413  202
                         builtInType_AST = (AST)currentAST.root;
 1414  202
                         break;
 1415  
                 }
 1416  
                 case LITERAL_char:
 1417  
                 {
 1418  328
                         AST tmp29_AST = null;
 1419  328
                         tmp29_AST = astFactory.create(LT(1));
 1420  328
                         astFactory.addASTChild(currentAST, tmp29_AST);
 1421  328
                         match(LITERAL_char);
 1422  328
                         builtInType_AST = (AST)currentAST.root;
 1423  328
                         break;
 1424  
                 }
 1425  
                 case LITERAL_short:
 1426  
                 {
 1427  55
                         AST tmp30_AST = null;
 1428  55
                         tmp30_AST = astFactory.create(LT(1));
 1429  55
                         astFactory.addASTChild(currentAST, tmp30_AST);
 1430  55
                         match(LITERAL_short);
 1431  55
                         builtInType_AST = (AST)currentAST.root;
 1432  55
                         break;
 1433  
                 }
 1434  
                 case LITERAL_int:
 1435  
                 {
 1436  20532
                         AST tmp31_AST = null;
 1437  20532
                         tmp31_AST = astFactory.create(LT(1));
 1438  20532
                         astFactory.addASTChild(currentAST, tmp31_AST);
 1439  20532
                         match(LITERAL_int);
 1440  20532
                         builtInType_AST = (AST)currentAST.root;
 1441  20532
                         break;
 1442  
                 }
 1443  
                 case LITERAL_float:
 1444  
                 {
 1445  208
                         AST tmp32_AST = null;
 1446  208
                         tmp32_AST = astFactory.create(LT(1));
 1447  208
                         astFactory.addASTChild(currentAST, tmp32_AST);
 1448  208
                         match(LITERAL_float);
 1449  208
                         builtInType_AST = (AST)currentAST.root;
 1450  208
                         break;
 1451  
                 }
 1452  
                 case LITERAL_long:
 1453  
                 {
 1454  628
                         AST tmp33_AST = null;
 1455  628
                         tmp33_AST = astFactory.create(LT(1));
 1456  628
                         astFactory.addASTChild(currentAST, tmp33_AST);
 1457  628
                         match(LITERAL_long);
 1458  628
                         builtInType_AST = (AST)currentAST.root;
 1459  628
                         break;
 1460  
                 }
 1461  
                 case LITERAL_double:
 1462  
                 {
 1463  483
                         AST tmp34_AST = null;
 1464  483
                         tmp34_AST = astFactory.create(LT(1));
 1465  483
                         astFactory.addASTChild(currentAST, tmp34_AST);
 1466  483
                         match(LITERAL_double);
 1467  483
                         builtInType_AST = (AST)currentAST.root;
 1468  483
                         break;
 1469  
                 }
 1470  
                 default:
 1471  
                 {
 1472  0
                         throw new NoViableAltException(LT(1), getFilename());
 1473  
                 }
 1474  
                 }
 1475  33264
                 returnAST = builtInType_AST;
 1476  33264
         }
 1477  
         
 1478  
         public final void type() throws RecognitionException, TokenStreamException {
 1479  
                 
 1480  5488
                 returnAST = null;
 1481  5488
                 ASTPair currentAST = new ASTPair();
 1482  5488
                 AST type_AST = null;
 1483  
                 
 1484  5488
                 switch ( LA(1)) {
 1485  
                 case IDENT:
 1486  
                 case AT:
 1487  
                 {
 1488  5032
                         classOrInterfaceType(false);
 1489  5032
                         astFactory.addASTChild(currentAST, returnAST);
 1490  5032
                         type_AST = (AST)currentAST.root;
 1491  5032
                         break;
 1492  
                 }
 1493  
                 case LITERAL_void:
 1494  
                 case LITERAL_boolean:
 1495  
                 case LITERAL_byte:
 1496  
                 case LITERAL_char:
 1497  
                 case LITERAL_short:
 1498  
                 case LITERAL_int:
 1499  
                 case LITERAL_float:
 1500  
                 case LITERAL_long:
 1501  
                 case LITERAL_double:
 1502  
                 {
 1503  456
                         builtInType();
 1504  456
                         astFactory.addASTChild(currentAST, returnAST);
 1505  456
                         type_AST = (AST)currentAST.root;
 1506  456
                         break;
 1507  
                 }
 1508  
                 default:
 1509  
                 {
 1510  0
                         throw new NoViableAltException(LT(1), getFilename());
 1511  
                 }
 1512  
                 }
 1513  5488
                 returnAST = type_AST;
 1514  5488
         }
 1515  
         
 1516  
 /** A declaration is the creation of a reference or primitive-type variable
 1517  
  *  Create a separate Type/Var tree for each var in the var list.
 1518  
     @throws RecognitionException if recognition problem occurs.
 1519  
     @throws TokenStreamException if problem occurs while generating a stream of tokens.
 1520  
  */
 1521  
         public final void declaration() throws RecognitionException, TokenStreamException {
 1522  
                 
 1523  19848
                 returnAST = null;
 1524  19848
                 ASTPair currentAST = new ASTPair();
 1525  19848
                 AST declaration_AST = null;
 1526  19848
                 AST m_AST = null;
 1527  19848
                 AST t_AST = null;
 1528  19848
                 AST v_AST = null;
 1529  
                 
 1530  19848
                 modifiers();
 1531  19848
                 m_AST = (AST)returnAST;
 1532  19848
                 typeSpec(false);
 1533  19802
                 t_AST = (AST)returnAST;
 1534  19802
                 variableDefinitions(m_AST,t_AST);
 1535  16164
                 v_AST = (AST)returnAST;
 1536  16164
                 if ( inputState.guessing==0 ) {
 1537  7208
                         declaration_AST = (AST)currentAST.root;
 1538  7208
                         declaration_AST = v_AST;
 1539  7208
                         currentAST.root = declaration_AST;
 1540  7208
                         currentAST.child = declaration_AST!=null &&declaration_AST.getFirstChild()!=null ?
 1541  7208
                                 declaration_AST.getFirstChild() : declaration_AST;
 1542  7208
                         currentAST.advanceChildToEnd();
 1543  
                 }
 1544  16164
                 returnAST = declaration_AST;
 1545  16164
         }
 1546  
         
 1547  
         public final void variableDefinitions(
 1548  
                 AST mods, AST t
 1549  
         ) throws RecognitionException, TokenStreamException {
 1550  
                 
 1551  26857
                 returnAST = null;
 1552  26857
                 ASTPair currentAST = new ASTPair();
 1553  26857
                 AST variableDefinitions_AST = null;
 1554  
                 
 1555  53714
                 variableDeclarator((AST) getASTFactory().dupTree(mods),
 1556  
                            //dupList as this also copies siblings (like TYPE_ARGUMENTS)
 1557  26857
                            (AST) getASTFactory().dupList(t));
 1558  23219
                 astFactory.addASTChild(currentAST, returnAST);
 1559  
                 {
 1560  
                 _loop165:
 1561  
                 do {
 1562  23726
                         if ((LA(1)==COMMA)) {
 1563  507
                                 AST tmp35_AST = null;
 1564  507
                                 tmp35_AST = astFactory.create(LT(1));
 1565  507
                                 astFactory.addASTChild(currentAST, tmp35_AST);
 1566  507
                                 match(COMMA);
 1567  1014
                                 variableDeclarator((AST) getASTFactory().dupTree(mods),
 1568  
                                //dupList as this also copies siblings (like TYPE_ARGUMENTS)
 1569  507
                                (AST) getASTFactory().dupList(t));
 1570  507
                                 astFactory.addASTChild(currentAST, returnAST);
 1571  507
                         }
 1572  
                         else {
 1573  
                                 break _loop165;
 1574  
                         }
 1575  
                         
 1576  
                 } while (true);
 1577  
                 }
 1578  23219
                 variableDefinitions_AST = (AST)currentAST.root;
 1579  23219
                 returnAST = variableDefinitions_AST;
 1580  23219
         }
 1581  
         
 1582  
         public final void modifier() throws RecognitionException, TokenStreamException {
 1583  
                 
 1584  22253
                 returnAST = null;
 1585  22253
                 ASTPair currentAST = new ASTPair();
 1586  22253
                 AST modifier_AST = null;
 1587  
                 
 1588  22253
                 switch ( LA(1)) {
 1589  
                 case LITERAL_private:
 1590  
                 {
 1591  5273
                         AST tmp36_AST = null;
 1592  5273
                         tmp36_AST = astFactory.create(LT(1));
 1593  5273
                         astFactory.addASTChild(currentAST, tmp36_AST);
 1594  5273
                         match(LITERAL_private);
 1595  5273
                         modifier_AST = (AST)currentAST.root;
 1596  5273
                         break;
 1597  
                 }
 1598  
                 case LITERAL_public:
 1599  
                 {
 1600  10285
                         AST tmp37_AST = null;
 1601  10285
                         tmp37_AST = astFactory.create(LT(1));
 1602  10285
                         astFactory.addASTChild(currentAST, tmp37_AST);
 1603  10285
                         match(LITERAL_public);
 1604  10285
                         modifier_AST = (AST)currentAST.root;
 1605  10285
                         break;
 1606  
                 }
 1607  
                 case LITERAL_protected:
 1608  
                 {
 1609  844
                         AST tmp38_AST = null;
 1610  844
                         tmp38_AST = astFactory.create(LT(1));
 1611  844
                         astFactory.addASTChild(currentAST, tmp38_AST);
 1612  844
                         match(LITERAL_protected);
 1613  844
                         modifier_AST = (AST)currentAST.root;
 1614  844
                         break;
 1615  
                 }
 1616  
                 case LITERAL_static:
 1617  
                 {
 1618  2558
                         AST tmp39_AST = null;
 1619  2558
                         tmp39_AST = astFactory.create(LT(1));
 1620  2558
                         astFactory.addASTChild(currentAST, tmp39_AST);
 1621  2558
                         match(LITERAL_static);
 1622  2558
                         modifier_AST = (AST)currentAST.root;
 1623  2558
                         break;
 1624  
                 }
 1625  
                 case LITERAL_transient:
 1626  
                 {
 1627  2
                         AST tmp40_AST = null;
 1628  2
                         tmp40_AST = astFactory.create(LT(1));
 1629  2
                         astFactory.addASTChild(currentAST, tmp40_AST);
 1630  2
                         match(LITERAL_transient);
 1631  2
                         modifier_AST = (AST)currentAST.root;
 1632  2
                         break;
 1633  
                 }
 1634  
                 case FINAL:
 1635  
                 {
 1636  2771
                         AST tmp41_AST = null;
 1637  2771
                         tmp41_AST = astFactory.create(LT(1));
 1638  2771
                         astFactory.addASTChild(currentAST, tmp41_AST);
 1639  2771
                         match(FINAL);
 1640  2771
                         modifier_AST = (AST)currentAST.root;
 1641  2771
                         break;
 1642  
                 }
 1643  
                 case ABSTRACT:
 1644  
                 {
 1645  334
                         AST tmp42_AST = null;
 1646  334
                         tmp42_AST = astFactory.create(LT(1));
 1647  334
                         astFactory.addASTChild(currentAST, tmp42_AST);
 1648  334
                         match(ABSTRACT);
 1649  334
                         modifier_AST = (AST)currentAST.root;
 1650  334
                         break;
 1651  
                 }
 1652  
                 case LITERAL_native:
 1653  
                 {
 1654  74
                         AST tmp43_AST = null;
 1655  74
                         tmp43_AST = astFactory.create(LT(1));
 1656  74
                         astFactory.addASTChild(currentAST, tmp43_AST);
 1657  74
                         match(LITERAL_native);
 1658  74
                         modifier_AST = (AST)currentAST.root;
 1659  74
                         break;
 1660  
                 }
 1661  
                 case LITERAL_synchronized:
 1662  
                 {
 1663  35
                         AST tmp44_AST = null;
 1664  35
                         tmp44_AST = astFactory.create(LT(1));
 1665  35
                         astFactory.addASTChild(currentAST, tmp44_AST);
 1666  35
                         match(LITERAL_synchronized);
 1667  35
                         modifier_AST = (AST)currentAST.root;
 1668  35
                         break;
 1669  
                 }
 1670  
                 case LITERAL_volatile:
 1671  
                 {
 1672  2
                         AST tmp45_AST = null;
 1673  2
                         tmp45_AST = astFactory.create(LT(1));
 1674  2
                         astFactory.addASTChild(currentAST, tmp45_AST);
 1675  2
                         match(LITERAL_volatile);
 1676  2
                         modifier_AST = (AST)currentAST.root;
 1677  2
                         break;
 1678  
                 }
 1679  
                 case STRICTFP:
 1680  
                 {
 1681  40
                         AST tmp46_AST = null;
 1682  40
                         tmp46_AST = astFactory.create(LT(1));
 1683  40
                         astFactory.addASTChild(currentAST, tmp46_AST);
 1684  40
                         match(STRICTFP);
 1685  40
                         modifier_AST = (AST)currentAST.root;
 1686  40
                         break;
 1687  
                 }
 1688  
                 case LITERAL_default:
 1689  
                 {
 1690  35
                         AST tmp47_AST = null;
 1691  35
                         tmp47_AST = astFactory.create(LT(1));
 1692  35
                         astFactory.addASTChild(currentAST, tmp47_AST);
 1693  35
                         match(LITERAL_default);
 1694  35
                         modifier_AST = (AST)currentAST.root;
 1695  35
                         break;
 1696  
                 }
 1697  
                 default:
 1698  
                 {
 1699  0
                         throw new NoViableAltException(LT(1), getFilename());
 1700  
                 }
 1701  
                 }
 1702  22253
                 returnAST = modifier_AST;
 1703  22253
         }
 1704  
         
 1705  
         public final void annotation() throws RecognitionException, TokenStreamException {
 1706  
                 
 1707  3545
                 returnAST = null;
 1708  3545
                 ASTPair currentAST = new ASTPair();
 1709  3545
                 AST annotation_AST = null;
 1710  3545
                 AST i_AST = null;
 1711  3545
                 Token  l = null;
 1712  3545
                 AST l_AST = null;
 1713  3545
                 AST args_AST = null;
 1714  3545
                 Token  r = null;
 1715  3545
                 AST r_AST = null;
 1716  
                 
 1717  3545
                 AST tmp48_AST = null;
 1718  3545
                 tmp48_AST = astFactory.create(LT(1));
 1719  3545
                 match(AT);
 1720  3545
                 identifier();
 1721  3545
                 i_AST = (AST)returnAST;
 1722  
                 {
 1723  3545
                 switch ( LA(1)) {
 1724  
                 case LPAREN:
 1725  
                 {
 1726  1551
                         l = LT(1);
 1727  1551
                         l_AST = astFactory.create(l);
 1728  1551
                         match(LPAREN);
 1729  
                         {
 1730  1551
                         switch ( LA(1)) {
 1731  
                         case LITERAL_void:
 1732  
                         case LITERAL_boolean:
 1733  
                         case LITERAL_byte:
 1734  
                         case LITERAL_char:
 1735  
                         case LITERAL_short:
 1736  
                         case LITERAL_int:
 1737  
                         case LITERAL_float:
 1738  
                         case LITERAL_long:
 1739  
                         case LITERAL_double:
 1740  
                         case IDENT:
 1741  
                         case LCURLY:
 1742  
                         case LPAREN:
 1743  
                         case LITERAL_this:
 1744  
                         case LITERAL_super:
 1745  
                         case PLUS:
 1746  
                         case MINUS:
 1747  
                         case INC:
 1748  
                         case DEC:
 1749  
                         case BNOT:
 1750  
                         case LNOT:
 1751  
                         case LITERAL_true:
 1752  
                         case LITERAL_false:
 1753  
                         case LITERAL_null:
 1754  
                         case LITERAL_new:
 1755  
                         case NUM_INT:
 1756  
                         case CHAR_LITERAL:
 1757  
                         case STRING_LITERAL:
 1758  
                         case NUM_FLOAT:
 1759  
                         case NUM_LONG:
 1760  
                         case NUM_DOUBLE:
 1761  
                         case AT:
 1762  
                         {
 1763  1520
                                 annotationArguments();
 1764  1520
                                 args_AST = (AST)returnAST;
 1765  1520
                                 break;
 1766  
                         }
 1767  
                         case RPAREN:
 1768  
                         {
 1769  31
                                 break;
 1770  
                         }
 1771  
                         default:
 1772  
                         {
 1773  0
                                 throw new NoViableAltException(LT(1), getFilename());
 1774  
                         }
 1775  
                         }
 1776  
                         }
 1777  1551
                         r = LT(1);
 1778  1551
                         r_AST = astFactory.create(r);
 1779  1551
                         match(RPAREN);
 1780  1551
                         break;
 1781  
                 }
 1782  
                 case FINAL:
 1783  
                 case ABSTRACT:
 1784  
                 case STRICTFP:
 1785  
                 case LITERAL_package:
 1786  
                 case SEMI:
 1787  
                 case LBRACK:
 1788  
                 case LITERAL_void:
 1789  
                 case LITERAL_boolean:
 1790  
                 case LITERAL_byte:
 1791  
                 case LITERAL_char:
 1792  
                 case LITERAL_short:
 1793  
                 case LITERAL_int:
 1794  
                 case LITERAL_float:
 1795  
                 case LITERAL_long:
 1796  
                 case LITERAL_double:
 1797  
                 case IDENT:
 1798  
                 case LITERAL_private:
 1799  
                 case LITERAL_public:
 1800  
                 case LITERAL_protected:
 1801  
                 case LITERAL_static:
 1802  
                 case LITERAL_transient:
 1803  
                 case LITERAL_native:
 1804  
                 case LITERAL_synchronized:
 1805  
                 case LITERAL_volatile:
 1806  
                 case LITERAL_class:
 1807  
                 case LITERAL_interface:
 1808  
                 case RCURLY:
 1809  
                 case COMMA:
 1810  
                 case RPAREN:
 1811  
                 case LITERAL_this:
 1812  
                 case LITERAL_default:
 1813  
                 case QUESTION:
 1814  
                 case LT:
 1815  
                 case ENUM:
 1816  
                 case AT:
 1817  
                 {
 1818  1994
                         break;
 1819  
                 }
 1820  
                 default:
 1821  
                 {
 1822  0
                         throw new NoViableAltException(LT(1), getFilename());
 1823  
                 }
 1824  
                 }
 1825  
                 }
 1826  3545
                 if ( inputState.guessing==0 ) {
 1827  2949
                         annotation_AST = (AST)currentAST.root;
 1828  2949
                         annotation_AST = (AST)astFactory.make( (new ASTArray(6)).add(astFactory.create(ANNOTATION,"ANNOTATION")).add(tmp48_AST).add(i_AST).add(l_AST).add(args_AST).add(r_AST));
 1829  2949
                         currentAST.root = annotation_AST;
 1830  2949
                         currentAST.child = annotation_AST!=null &&annotation_AST.getFirstChild()!=null ?
 1831  2949
                                 annotation_AST.getFirstChild() : annotation_AST;
 1832  2949
                         currentAST.advanceChildToEnd();
 1833  
                 }
 1834  3545
                 returnAST = annotation_AST;
 1835  3545
         }
 1836  
         
 1837  
         public final void annotationArguments() throws RecognitionException, TokenStreamException {
 1838  
                 
 1839  1520
                 returnAST = null;
 1840  1520
                 ASTPair currentAST = new ASTPair();
 1841  1520
                 AST annotationArguments_AST = null;
 1842  
                 
 1843  1520
                 if ((_tokenSet_10.member(LA(1))) && (_tokenSet_11.member(LA(2)))) {
 1844  941
                         annotationMemberValueInitializer();
 1845  941
                         astFactory.addASTChild(currentAST, returnAST);
 1846  941
                         annotationArguments_AST = (AST)currentAST.root;
 1847  
                 }
 1848  579
                 else if ((LA(1)==IDENT) && (LA(2)==ASSIGN)) {
 1849  579
                         annotationMemberValuePairs();
 1850  579
                         astFactory.addASTChild(currentAST, returnAST);
 1851  579
                         annotationArguments_AST = (AST)currentAST.root;
 1852  
                 }
 1853  
                 else {
 1854  0
                         throw new NoViableAltException(LT(1), getFilename());
 1855  
                 }
 1856  
                 
 1857  1520
                 returnAST = annotationArguments_AST;
 1858  1520
         }
 1859  
         
 1860  
         public final void annotationMemberValueInitializer() throws RecognitionException, TokenStreamException {
 1861  
                 
 1862  1758
                 returnAST = null;
 1863  1758
                 ASTPair currentAST = new ASTPair();
 1864  1758
                 AST annotationMemberValueInitializer_AST = null;
 1865  
                 
 1866  1758
                 boolean synPredMatched76 = false;
 1867  1758
                 if (((_tokenSet_12.member(LA(1))) && (_tokenSet_13.member(LA(2))))) {
 1868  1038
                         int _m76 = mark();
 1869  1038
                         synPredMatched76 = true;
 1870  1038
                         inputState.guessing++;
 1871  
                         try {
 1872  
                                 {
 1873  1038
                                 annotationExpression();
 1874  
                                 }
 1875  
                         }
 1876  18
                         catch (RecognitionException pe) {
 1877  18
                                 synPredMatched76 = false;
 1878  1020
                         }
 1879  1038
                         rewind(_m76);
 1880  1038
 inputState.guessing--;
 1881  
                 }
 1882  1758
                 if ( synPredMatched76 ) {
 1883  1020
                         annotationExpression();
 1884  1020
                         astFactory.addASTChild(currentAST, returnAST);
 1885  1020
                         annotationMemberValueInitializer_AST = (AST)currentAST.root;
 1886  
                 }
 1887  738
                 else if ((LA(1)==AT) && (LA(2)==IDENT)) {
 1888  18
                         annotation();
 1889  18
                         astFactory.addASTChild(currentAST, returnAST);
 1890  18
                         annotationMemberValueInitializer_AST = (AST)currentAST.root;
 1891  
                 }
 1892  720
                 else if ((LA(1)==LCURLY)) {
 1893  720
                         annotationMemberArrayInitializer();
 1894  720
                         astFactory.addASTChild(currentAST, returnAST);
 1895  720
                         annotationMemberValueInitializer_AST = (AST)currentAST.root;
 1896  
                 }
 1897  
                 else {
 1898  0
                         throw new NoViableAltException(LT(1), getFilename());
 1899  
                 }
 1900  
                 
 1901  1758
                 returnAST = annotationMemberValueInitializer_AST;
 1902  1758
         }
 1903  
         
 1904  
         public final void annotationMemberValuePairs() throws RecognitionException, TokenStreamException {
 1905  
                 
 1906  579
                 returnAST = null;
 1907  579
                 ASTPair currentAST = new ASTPair();
 1908  579
                 AST annotationMemberValuePairs_AST = null;
 1909  
                 
 1910  579
                 annotationMemberValuePair();
 1911  579
                 astFactory.addASTChild(currentAST, returnAST);
 1912  
                 {
 1913  
                 _loop72:
 1914  
                 do {
 1915  720
                         if ((LA(1)==COMMA)) {
 1916  141
                                 AST tmp49_AST = null;
 1917  141
                                 tmp49_AST = astFactory.create(LT(1));
 1918  141
                                 astFactory.addASTChild(currentAST, tmp49_AST);
 1919  141
                                 match(COMMA);
 1920  141
                                 annotationMemberValuePair();
 1921  141
                                 astFactory.addASTChild(currentAST, returnAST);
 1922  141
                         }
 1923  
                         else {
 1924  
                                 break _loop72;
 1925  
                         }
 1926  
                         
 1927  
                 } while (true);
 1928  
                 }
 1929  579
                 annotationMemberValuePairs_AST = (AST)currentAST.root;
 1930  579
                 returnAST = annotationMemberValuePairs_AST;
 1931  579
         }
 1932  
         
 1933  
         public final void annotationMemberValuePair() throws RecognitionException, TokenStreamException {
 1934  
                 
 1935  720
                 returnAST = null;
 1936  720
                 ASTPair currentAST = new ASTPair();
 1937  720
                 AST annotationMemberValuePair_AST = null;
 1938  720
                 Token  i = null;
 1939  720
                 AST i_AST = null;
 1940  720
                 Token  a = null;
 1941  720
                 AST a_AST = null;
 1942  720
                 AST v_AST = null;
 1943  
                 
 1944  720
                 i = LT(1);
 1945  720
                 i_AST = astFactory.create(i);
 1946  720
                 match(IDENT);
 1947  720
                 a = LT(1);
 1948  720
                 a_AST = astFactory.create(a);
 1949  720
                 match(ASSIGN);
 1950  720
                 annotationMemberValueInitializer();
 1951  720
                 v_AST = (AST)returnAST;
 1952  720
                 if ( inputState.guessing==0 ) {
 1953  576
                         annotationMemberValuePair_AST = (AST)currentAST.root;
 1954  576
                         annotationMemberValuePair_AST =
 1955  576
                         (AST)astFactory.make( (new ASTArray(4)).add(astFactory.create(ANNOTATION_MEMBER_VALUE_PAIR,"ANNOTATION_MEMBER_VALUE_PAIR")).add(i_AST).add(a_AST).add(v_AST));
 1956  576
                         currentAST.root = annotationMemberValuePair_AST;
 1957  576
                         currentAST.child = annotationMemberValuePair_AST!=null &&annotationMemberValuePair_AST.getFirstChild()!=null ?
 1958  576
                                 annotationMemberValuePair_AST.getFirstChild() : annotationMemberValuePair_AST;
 1959  576
                         currentAST.advanceChildToEnd();
 1960  
                 }
 1961  720
                 returnAST = annotationMemberValuePair_AST;
 1962  720
         }
 1963  
         
 1964  
         public final void annotationExpression() throws RecognitionException, TokenStreamException {
 1965  
                 
 1966  3822
                 returnAST = null;
 1967  3822
                 ASTPair currentAST = new ASTPair();
 1968  3822
                 AST annotationExpression_AST = null;
 1969  
                 
 1970  3822
                 conditionalExpression();
 1971  3768
                 astFactory.addASTChild(currentAST, returnAST);
 1972  3768
                 if ( inputState.guessing==0 ) {
 1973  1622
                         annotationExpression_AST = (AST)currentAST.root;
 1974  1622
                         annotationExpression_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(EXPR,"EXPR")).add(annotationExpression_AST));
 1975  1622
                         currentAST.root = annotationExpression_AST;
 1976  1622
                         currentAST.child = annotationExpression_AST!=null &&annotationExpression_AST.getFirstChild()!=null ?
 1977  1622
                                 annotationExpression_AST.getFirstChild() : annotationExpression_AST;
 1978  1622
                         currentAST.advanceChildToEnd();
 1979  
                 }
 1980  3768
                 annotationExpression_AST = (AST)currentAST.root;
 1981  3768
                 returnAST = annotationExpression_AST;
 1982  3768
         }
 1983  
         
 1984  
         public final void annotationMemberArrayInitializer() throws RecognitionException, TokenStreamException {
 1985  
                 
 1986  720
                 returnAST = null;
 1987  720
                 ASTPair currentAST = new ASTPair();
 1988  720
                 AST annotationMemberArrayInitializer_AST = null;
 1989  720
                 Token  lc = null;
 1990  720
                 AST lc_AST = null;
 1991  
                 
 1992  720
                 lc = LT(1);
 1993  720
                 lc_AST = astFactory.create(lc);
 1994  720
                 astFactory.makeASTRoot(currentAST, lc_AST);
 1995  720
                 match(LCURLY);
 1996  720
                 if ( inputState.guessing==0 ) {
 1997  642
                         lc_AST.setType(ANNOTATION_ARRAY_INIT);
 1998  
                 }
 1999  
                 {
 2000  720
                 switch ( LA(1)) {
 2001  
                 case LITERAL_void:
 2002  
                 case LITERAL_boolean:
 2003  
                 case LITERAL_byte:
 2004  
                 case LITERAL_char:
 2005  
                 case LITERAL_short:
 2006  
                 case LITERAL_int:
 2007  
                 case LITERAL_float:
 2008  
                 case LITERAL_long:
 2009  
                 case LITERAL_double:
 2010  
                 case IDENT:
 2011  
                 case LPAREN:
 2012  
                 case LITERAL_this:
 2013  
                 case LITERAL_super:
 2014  
                 case PLUS:
 2015  
                 case MINUS:
 2016  
                 case INC:
 2017  
                 case DEC:
 2018  
                 case BNOT:
 2019  
                 case LNOT:
 2020  
                 case LITERAL_true:
 2021  
                 case LITERAL_false:
 2022  
                 case LITERAL_null:
 2023  
                 case LITERAL_new:
 2024  
                 case NUM_INT:
 2025  
                 case CHAR_LITERAL:
 2026  
                 case STRING_LITERAL:
 2027  
                 case NUM_FLOAT:
 2028  
                 case NUM_LONG:
 2029  
                 case NUM_DOUBLE:
 2030  
                 case AT:
 2031  
                 {
 2032  605
                         annotationMemberArrayValueInitializer();
 2033  605
                         astFactory.addASTChild(currentAST, returnAST);
 2034  
                         {
 2035  
                         _loop80:
 2036  
                         do {
 2037  900
                                 if ((LA(1)==COMMA) && (_tokenSet_12.member(LA(2)))) {
 2038  295
                                         AST tmp50_AST = null;
 2039  295
                                         tmp50_AST = astFactory.create(LT(1));
 2040  295
                                         astFactory.addASTChild(currentAST, tmp50_AST);
 2041  295
                                         match(COMMA);
 2042  295
                                         annotationMemberArrayValueInitializer();
 2043  295
                                         astFactory.addASTChild(currentAST, returnAST);
 2044  295
                                 }
 2045  
                                 else {
 2046  
                                         break _loop80;
 2047  
                                 }
 2048  
                                 
 2049  
                         } while (true);
 2050  
                         }
 2051  
                         {
 2052  605
                         switch ( LA(1)) {
 2053  
                         case COMMA:
 2054  
                         {
 2055  41
                                 AST tmp51_AST = null;
 2056  41
                                 tmp51_AST = astFactory.create(LT(1));
 2057  41
                                 astFactory.addASTChild(currentAST, tmp51_AST);
 2058  41
                                 match(COMMA);
 2059  41
                                 break;
 2060  
                         }
 2061  
                         case RCURLY:
 2062  
                         {
 2063  564
                                 break;
 2064  
                         }
 2065  
                         default:
 2066  
                         {
 2067  0
                                 throw new NoViableAltException(LT(1), getFilename());
 2068  
                         }
 2069  
                         }
 2070  
                         }
 2071  
                         break;
 2072  
                 }
 2073  
                 case RCURLY:
 2074  
                 {
 2075  115
                         break;
 2076  
                 }
 2077  
                 default:
 2078  
                 {
 2079  0
                         throw new NoViableAltException(LT(1), getFilename());
 2080  
                 }
 2081  
                 }
 2082  
                 }
 2083  720
                 AST tmp52_AST = null;
 2084  720
                 tmp52_AST = astFactory.create(LT(1));
 2085  720
                 astFactory.addASTChild(currentAST, tmp52_AST);
 2086  720
                 match(RCURLY);
 2087  720
                 annotationMemberArrayInitializer_AST = (AST)currentAST.root;
 2088  720
                 returnAST = annotationMemberArrayInitializer_AST;
 2089  720
         }
 2090  
         
 2091  
         public final void annotationMemberArrayValueInitializer() throws RecognitionException, TokenStreamException {
 2092  
                 
 2093  900
                 returnAST = null;
 2094  900
                 ASTPair currentAST = new ASTPair();
 2095  900
                 AST annotationMemberArrayValueInitializer_AST = null;
 2096  
                 
 2097  900
                 boolean synPredMatched84 = false;
 2098  900
                 if (((_tokenSet_12.member(LA(1))) && (_tokenSet_14.member(LA(2))))) {
 2099  900
                         int _m84 = mark();
 2100  900
                         synPredMatched84 = true;
 2101  900
                         inputState.guessing++;
 2102  
                         try {
 2103  
                                 {
 2104  900
                                 annotationExpression();
 2105  
                                 }
 2106  
                         }
 2107  36
                         catch (RecognitionException pe) {
 2108  36
                                 synPredMatched84 = false;
 2109  864
                         }
 2110  900
                         rewind(_m84);
 2111  900
 inputState.guessing--;
 2112  
                 }
 2113  900
                 if ( synPredMatched84 ) {
 2114  864
                         annotationExpression();
 2115  864
                         astFactory.addASTChild(currentAST, returnAST);
 2116  864
                         annotationMemberArrayValueInitializer_AST = (AST)currentAST.root;
 2117  
                 }
 2118  36
                 else if ((LA(1)==AT) && (LA(2)==IDENT)) {
 2119  36
                         annotation();
 2120  36
                         astFactory.addASTChild(currentAST, returnAST);
 2121  36
                         annotationMemberArrayValueInitializer_AST = (AST)currentAST.root;
 2122  
                 }
 2123  
                 else {
 2124  0
                         throw new NoViableAltException(LT(1), getFilename());
 2125  
                 }
 2126  
                 
 2127  900
                 returnAST = annotationMemberArrayValueInitializer_AST;
 2128  900
         }
 2129  
         
 2130  
         public final void conditionalExpression() throws RecognitionException, TokenStreamException {
 2131  
                 
 2132  80375
                 returnAST = null;
 2133  80375
                 ASTPair currentAST = new ASTPair();
 2134  80375
                 AST conditionalExpression_AST = null;
 2135  
                 
 2136  80375
                 logicalOrExpression();
 2137  80305
                 astFactory.addASTChild(currentAST, returnAST);
 2138  
                 {
 2139  80305
                 switch ( LA(1)) {
 2140  
                 case QUESTION:
 2141  
                 {
 2142  1035
                         AST tmp53_AST = null;
 2143  1035
                         tmp53_AST = astFactory.create(LT(1));
 2144  1035
                         astFactory.makeASTRoot(currentAST, tmp53_AST);
 2145  1035
                         match(QUESTION);
 2146  
                         {
 2147  1035
                         boolean synPredMatched284 = false;
 2148  1035
                         if (((LA(1)==IDENT||LA(1)==LPAREN) && (_tokenSet_15.member(LA(2))))) {
 2149  8
                                 int _m284 = mark();
 2150  8
                                 synPredMatched284 = true;
 2151  8
                                 inputState.guessing++;
 2152  
                                 try {
 2153  
                                         {
 2154  8
                                         lambdaExpression();
 2155  
                                         }
 2156  
                                 }
 2157  8
                                 catch (RecognitionException pe) {
 2158  8
                                         synPredMatched284 = false;
 2159  0
                                 }
 2160  8
                                 rewind(_m284);
 2161  8
 inputState.guessing--;
 2162  
                         }
 2163  1035
                         if ( synPredMatched284 ) {
 2164  0
                                 lambdaExpression();
 2165  0
                                 astFactory.addASTChild(currentAST, returnAST);
 2166  
                         }
 2167  1035
                         else if ((_tokenSet_12.member(LA(1))) && (_tokenSet_16.member(LA(2)))) {
 2168  1035
                                 assignmentExpression();
 2169  1035
                                 astFactory.addASTChild(currentAST, returnAST);
 2170  
                         }
 2171  
                         else {
 2172  0
                                 throw new NoViableAltException(LT(1), getFilename());
 2173  
                         }
 2174  
                         
 2175  
                         }
 2176  1035
                         AST tmp54_AST = null;
 2177  1035
                         tmp54_AST = astFactory.create(LT(1));
 2178  1035
                         astFactory.addASTChild(currentAST, tmp54_AST);
 2179  1035
                         match(COLON);
 2180  
                         {
 2181  1035
                         boolean synPredMatched287 = false;
 2182  1035
                         if (((LA(1)==IDENT||LA(1)==LPAREN) && (_tokenSet_15.member(LA(2))))) {
 2183  26
                                 int _m287 = mark();
 2184  26
                                 synPredMatched287 = true;
 2185  26
                                 inputState.guessing++;
 2186  
                                 try {
 2187  
                                         {
 2188  26
                                         lambdaExpression();
 2189  
                                         }
 2190  
                                 }
 2191  20
                                 catch (RecognitionException pe) {
 2192  20
                                         synPredMatched287 = false;
 2193  6
                                 }
 2194  26
                                 rewind(_m287);
 2195  26
 inputState.guessing--;
 2196  
                         }
 2197  1035
                         if ( synPredMatched287 ) {
 2198  6
                                 lambdaExpression();
 2199  6
                                 astFactory.addASTChild(currentAST, returnAST);
 2200  
                         }
 2201  1029
                         else if ((_tokenSet_12.member(LA(1))) && (_tokenSet_17.member(LA(2)))) {
 2202  1029
                                 conditionalExpression();
 2203  1029
                                 astFactory.addASTChild(currentAST, returnAST);
 2204  
                         }
 2205  
                         else {
 2206  0
                                 throw new NoViableAltException(LT(1), getFilename());
 2207  
                         }
 2208  
                         
 2209  
                         }
 2210  1035
                         break;
 2211  
                 }
 2212  
                 case FINAL:
 2213  
                 case ABSTRACT:
 2214  
                 case STRICTFP:
 2215  
                 case SEMI:
 2216  
                 case RBRACK:
 2217  
                 case LITERAL_void:
 2218  
                 case LITERAL_boolean:
 2219  
                 case LITERAL_byte:
 2220  
                 case LITERAL_char:
 2221  
                 case LITERAL_short:
 2222  
                 case LITERAL_int:
 2223  
                 case LITERAL_float:
 2224  
                 case LITERAL_long:
 2225  
                 case LITERAL_double:
 2226  
                 case IDENT:
 2227  
                 case STAR:
 2228  
                 case LITERAL_private:
 2229  
                 case LITERAL_public:
 2230  
                 case LITERAL_protected:
 2231  
                 case LITERAL_static:
 2232  
                 case LITERAL_transient:
 2233  
                 case LITERAL_native:
 2234  
                 case LITERAL_synchronized:
 2235  
                 case LITERAL_volatile:
 2236  
                 case LITERAL_class:
 2237  
                 case LITERAL_interface:
 2238  
                 case LCURLY:
 2239  
                 case RCURLY:
 2240  
                 case COMMA:
 2241  
                 case LPAREN:
 2242  
                 case RPAREN:
 2243  
                 case LITERAL_this:
 2244  
                 case LITERAL_super:
 2245  
                 case ASSIGN:
 2246  
                 case COLON:
 2247  
                 case LITERAL_if:
 2248  
                 case LITERAL_while:
 2249  
                 case LITERAL_do:
 2250  
                 case LITERAL_break:
 2251  
                 case LITERAL_continue:
 2252  
                 case LITERAL_return:
 2253  
                 case LITERAL_switch:
 2254  
                 case LITERAL_throw:
 2255  
                 case LITERAL_for:
 2256  
                 case LITERAL_else:
 2257  
                 case LITERAL_case:
 2258  
                 case LITERAL_default:
 2259  
                 case LITERAL_try:
 2260  
                 case PLUS_ASSIGN:
 2261  
                 case MINUS_ASSIGN:
 2262  
                 case STAR_ASSIGN:
 2263  
                 case DIV_ASSIGN:
 2264  
                 case MOD_ASSIGN:
 2265  
                 case SR_ASSIGN:
 2266  
                 case BSR_ASSIGN:
 2267  
                 case SL_ASSIGN:
 2268  
                 case BAND_ASSIGN:
 2269  
                 case BXOR_ASSIGN:
 2270  
                 case BOR_ASSIGN:
 2271  
                 case LT:
 2272  
                 case GT:
 2273  
                 case LE:
 2274  
                 case GE:
 2275  
                 case LITERAL_instanceof:
 2276  
                 case SL:
 2277  
                 case SR:
 2278  
                 case BSR:
 2279  
                 case PLUS:
 2280  
                 case MINUS:
 2281  
                 case DIV:
 2282  
                 case MOD:
 2283  
                 case INC:
 2284  
                 case DEC:
 2285  
                 case BNOT:
 2286  
                 case LNOT:
 2287  
                 case LITERAL_true:
 2288  
                 case LITERAL_false:
 2289  
                 case LITERAL_null:
 2290  
                 case LITERAL_new:
 2291  
                 case NUM_INT:
 2292  
                 case CHAR_LITERAL:
 2293  
                 case STRING_LITERAL:
 2294  
                 case NUM_FLOAT:
 2295  
                 case NUM_LONG:
 2296  
                 case NUM_DOUBLE:
 2297  
                 case ASSERT:
 2298  
                 case ENUM:
 2299  
                 case AT:
 2300  
                 {
 2301  79270
                         break;
 2302  
                 }
 2303  
                 default:
 2304  
                 {
 2305  0
                         throw new NoViableAltException(LT(1), getFilename());
 2306  
                 }
 2307  
                 }
 2308  
                 }
 2309  80305
                 conditionalExpression_AST = (AST)currentAST.root;
 2310  80305
                 returnAST = conditionalExpression_AST;
 2311  80305
         }
 2312  
         
 2313  
         public final void typeParameters() throws RecognitionException, TokenStreamException {
 2314  
                 
 2315  604
                 returnAST = null;
 2316  604
                 ASTPair currentAST = new ASTPair();
 2317  604
                 AST typeParameters_AST = null;
 2318  604
                 Token  lt = null;
 2319  604
                 AST lt_AST = null;
 2320  604
                 int currentLtLevel = 0;
 2321  
                 
 2322  604
                 if ( inputState.guessing==0 ) {
 2323  595
                         currentLtLevel = ltCounter;
 2324  
                 }
 2325  604
                 lt = LT(1);
 2326  604
                 lt_AST = astFactory.create(lt);
 2327  604
                 astFactory.addASTChild(currentAST, lt_AST);
 2328  604
                 match(LT);
 2329  604
                 if ( inputState.guessing==0 ) {
 2330  595
                         lt_AST.setType(GENERIC_START); ltCounter++;
 2331  
                 }
 2332  604
                 typeParameter();
 2333  604
                 astFactory.addASTChild(currentAST, returnAST);
 2334  
                 {
 2335  
                 _loop96:
 2336  
                 do {
 2337  768
                         if ((LA(1)==COMMA)) {
 2338  164
                                 AST tmp55_AST = null;
 2339  164
                                 tmp55_AST = astFactory.create(LT(1));
 2340  164
                                 astFactory.addASTChild(currentAST, tmp55_AST);
 2341  164
                                 match(COMMA);
 2342  164
                                 typeParameter();
 2343  164
                                 astFactory.addASTChild(currentAST, returnAST);
 2344  164
                         }
 2345  
                         else {
 2346  
                                 break _loop96;
 2347  
                         }
 2348  
                         
 2349  
                 } while (true);
 2350  
                 }
 2351  
                 {
 2352  604
                 switch ( LA(1)) {
 2353  
                 case GT:
 2354  
                 case SR:
 2355  
                 case BSR:
 2356  
                 {
 2357  594
                         typeArgumentsOrParametersEnd();
 2358  594
                         astFactory.addASTChild(currentAST, returnAST);
 2359  594
                         break;
 2360  
                 }
 2361  
                 case LITERAL_void:
 2362  
                 case LITERAL_boolean:
 2363  
                 case LITERAL_byte:
 2364  
                 case LITERAL_char:
 2365  
                 case LITERAL_short:
 2366  
                 case LITERAL_int:
 2367  
                 case LITERAL_float:
 2368  
                 case LITERAL_long:
 2369  
                 case LITERAL_double:
 2370  
                 case IDENT:
 2371  
                 case LITERAL_extends:
 2372  
                 case LCURLY:
 2373  
                 case LITERAL_implements:
 2374  
                 case AT:
 2375  
                 {
 2376  10
                         break;
 2377  
                 }
 2378  
                 default:
 2379  
                 {
 2380  0
                         throw new NoViableAltException(LT(1), getFilename());
 2381  
                 }
 2382  
                 }
 2383  
                 }
 2384  604
                 if ( inputState.guessing==0 ) {
 2385  
                         
 2386  595
                         if (isThereASingleGtToEmit()) {
 2387  595
                         astFactory.addASTChild(currentAST, emitSingleGt());
 2388  
                         }
 2389  
                         
 2390  
                 }
 2391  604
                 if (!(areLtsAndGtsBalanced(currentLtLevel)))
 2392  0
                   throw new SemanticException("areLtsAndGtsBalanced(currentLtLevel)");
 2393  604
                 if ( inputState.guessing==0 ) {
 2394  595
                         typeParameters_AST = (AST)currentAST.root;
 2395  595
                         typeParameters_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(TYPE_PARAMETERS,"TYPE_PARAMETERS")).add(typeParameters_AST));
 2396  595
                         currentAST.root = typeParameters_AST;
 2397  595
                         currentAST.child = typeParameters_AST!=null &&typeParameters_AST.getFirstChild()!=null ?
 2398  595
                                 typeParameters_AST.getFirstChild() : typeParameters_AST;
 2399  595
                         currentAST.advanceChildToEnd();
 2400  
                 }
 2401  604
                 typeParameters_AST = (AST)currentAST.root;
 2402  604
                 returnAST = typeParameters_AST;
 2403  604
         }
 2404  
         
 2405  
         public final void superClassClause() throws RecognitionException, TokenStreamException {
 2406  
                 
 2407  4980
                 returnAST = null;
 2408  4980
                 ASTPair currentAST = new ASTPair();
 2409  4980
                 AST superClassClause_AST = null;
 2410  4980
                 Token  e = null;
 2411  4980
                 AST e_AST = null;
 2412  4980
                 AST c_AST = null;
 2413  
                 
 2414  
                 {
 2415  4980
                 switch ( LA(1)) {
 2416  
                 case LITERAL_extends:
 2417  
                 {
 2418  213
                         e = LT(1);
 2419  213
                         e_AST = astFactory.create(e);
 2420  213
                         astFactory.makeASTRoot(currentAST, e_AST);
 2421  213
                         match(LITERAL_extends);
 2422  213
                         if ( inputState.guessing==0 ) {
 2423  213
                                 e_AST.setType(EXTENDS_CLAUSE);
 2424  
                         }
 2425  213
                         classOrInterfaceType(false);
 2426  213
                         c_AST = (AST)returnAST;
 2427  213
                         astFactory.addASTChild(currentAST, returnAST);
 2428  213
                         break;
 2429  
                 }
 2430  
                 case LCURLY:
 2431  
                 case LITERAL_implements:
 2432  
                 {
 2433  4767
                         break;
 2434  
                 }
 2435  
                 default:
 2436  
                 {
 2437  0
                         throw new NoViableAltException(LT(1), getFilename());
 2438  
                 }
 2439  
                 }
 2440  
                 }
 2441  4980
                 superClassClause_AST = (AST)currentAST.root;
 2442  4980
                 returnAST = superClassClause_AST;
 2443  4980
         }
 2444  
         
 2445  
         public final void implementsClause() throws RecognitionException, TokenStreamException {
 2446  
                 
 2447  5443
                 returnAST = null;
 2448  5443
                 ASTPair currentAST = new ASTPair();
 2449  5443
                 AST implementsClause_AST = null;
 2450  5443
                 Token  i = null;
 2451  5443
                 AST i_AST = null;
 2452  
                 
 2453  
                 {
 2454  5443
                 switch ( LA(1)) {
 2455  
                 case LITERAL_implements:
 2456  
                 {
 2457  118
                         i = LT(1);
 2458  118
                         i_AST = astFactory.create(i);
 2459  118
                         astFactory.makeASTRoot(currentAST, i_AST);
 2460  118
                         match(LITERAL_implements);
 2461  118
                         if ( inputState.guessing==0 ) {
 2462  118
                                 i_AST.setType(IMPLEMENTS_CLAUSE);
 2463  
                         }
 2464  118
                         classOrInterfaceType(false);
 2465  118
                         astFactory.addASTChild(currentAST, returnAST);
 2466  
                         {
 2467  
                         _loop143:
 2468  
                         do {
 2469  134
                                 if ((LA(1)==COMMA)) {
 2470  16
                                         AST tmp56_AST = null;
 2471  16
                                         tmp56_AST = astFactory.create(LT(1));
 2472  16
                                         astFactory.addASTChild(currentAST, tmp56_AST);
 2473  16
                                         match(COMMA);
 2474  16
                                         classOrInterfaceType(false);
 2475  16
                                         astFactory.addASTChild(currentAST, returnAST);
 2476  16
                                 }
 2477  
                                 else {
 2478  
                                         break _loop143;
 2479  
                                 }
 2480  
                                 
 2481  
                         } while (true);
 2482  
                         }
 2483  
                         break;
 2484  
                 }
 2485  
                 case LCURLY:
 2486  
                 {
 2487  5325
                         break;
 2488  
                 }
 2489  
                 default:
 2490  
                 {
 2491  0
                         throw new NoViableAltException(LT(1), getFilename());
 2492  
                 }
 2493  
                 }
 2494  
                 }
 2495  5443
                 implementsClause_AST = (AST)currentAST.root;
 2496  5443
                 returnAST = implementsClause_AST;
 2497  5443
         }
 2498  
         
 2499  
         public final void classBlock() throws RecognitionException, TokenStreamException {
 2500  
                 
 2501  6845
                 returnAST = null;
 2502  6845
                 ASTPair currentAST = new ASTPair();
 2503  6845
                 AST classBlock_AST = null;
 2504  
                 
 2505  6845
                 AST tmp57_AST = null;
 2506  6845
                 tmp57_AST = astFactory.create(LT(1));
 2507  6845
                 astFactory.addASTChild(currentAST, tmp57_AST);
 2508  6845
                 match(LCURLY);
 2509  
                 {
 2510  
                 _loop135:
 2511  
                 do {
 2512  28780
                         switch ( LA(1)) {
 2513  
                         case FINAL:
 2514  
                         case ABSTRACT:
 2515  
                         case STRICTFP:
 2516  
                         case LITERAL_void:
 2517  
                         case LITERAL_boolean:
 2518  
                         case LITERAL_byte:
 2519  
                         case LITERAL_char:
 2520  
                         case LITERAL_short:
 2521  
                         case LITERAL_int:
 2522  
                         case LITERAL_float:
 2523  
                         case LITERAL_long:
 2524  
                         case LITERAL_double:
 2525  
                         case IDENT:
 2526  
                         case LITERAL_private:
 2527  
                         case LITERAL_public:
 2528  
                         case LITERAL_protected:
 2529  
                         case LITERAL_static:
 2530  
                         case LITERAL_transient:
 2531  
                         case LITERAL_native:
 2532  
                         case LITERAL_synchronized:
 2533  
                         case LITERAL_volatile:
 2534  
                         case LITERAL_class:
 2535  
                         case LITERAL_interface:
 2536  
                         case LCURLY:
 2537  
                         case LITERAL_default:
 2538  
                         case LT:
 2539  
                         case ENUM:
 2540  
                         case AT:
 2541  
                         {
 2542  21818
                                 field();
 2543  21818
                                 astFactory.addASTChild(currentAST, returnAST);
 2544  21818
                                 break;
 2545  
                         }
 2546  
                         case SEMI:
 2547  
                         {
 2548  117
                                 AST tmp58_AST = null;
 2549  117
                                 tmp58_AST = astFactory.create(LT(1));
 2550  117
                                 astFactory.addASTChild(currentAST, tmp58_AST);
 2551  117
                                 match(SEMI);
 2552  117
                                 break;
 2553  
                         }
 2554  
                         default:
 2555  
                         {
 2556  6845
                                 break _loop135;
 2557  
                         }
 2558  
                         }
 2559  
                 } while (true);
 2560  
                 }
 2561  6845
                 AST tmp59_AST = null;
 2562  6845
                 tmp59_AST = astFactory.create(LT(1));
 2563  6845
                 astFactory.addASTChild(currentAST, tmp59_AST);
 2564  6845
                 match(RCURLY);
 2565  6845
                 if ( inputState.guessing==0 ) {
 2566  6333
                         classBlock_AST = (AST)currentAST.root;
 2567  6333
                         classBlock_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(OBJBLOCK,"OBJBLOCK")).add(classBlock_AST));
 2568  6333
                         currentAST.root = classBlock_AST;
 2569  6333
                         currentAST.child = classBlock_AST!=null &&classBlock_AST.getFirstChild()!=null ?
 2570  6333
                                 classBlock_AST.getFirstChild() : classBlock_AST;
 2571  6333
                         currentAST.advanceChildToEnd();
 2572  
                 }
 2573  6845
                 classBlock_AST = (AST)currentAST.root;
 2574  6845
                 returnAST = classBlock_AST;
 2575  6845
         }
 2576  
         
 2577  
         public final void interfaceExtends() throws RecognitionException, TokenStreamException {
 2578  
                 
 2579  640
                 returnAST = null;
 2580  640
                 ASTPair currentAST = new ASTPair();
 2581  640
                 AST interfaceExtends_AST = null;
 2582  640
                 Token  e = null;
 2583  640
                 AST e_AST = null;
 2584  
                 
 2585  
                 {
 2586  640
                 switch ( LA(1)) {
 2587  
                 case LITERAL_extends:
 2588  
                 {
 2589  28
                         e = LT(1);
 2590  28
                         e_AST = astFactory.create(e);
 2591  28
                         astFactory.makeASTRoot(currentAST, e_AST);
 2592  28
                         match(LITERAL_extends);
 2593  28
                         if ( inputState.guessing==0 ) {
 2594  28
                                 e_AST.setType(EXTENDS_CLAUSE);
 2595  
                         }
 2596  28
                         classOrInterfaceType(false);
 2597  28
                         astFactory.addASTChild(currentAST, returnAST);
 2598  
                         {
 2599  
                         _loop139:
 2600  
                         do {
 2601  32
                                 if ((LA(1)==COMMA)) {
 2602  4
                                         AST tmp60_AST = null;
 2603  4
                                         tmp60_AST = astFactory.create(LT(1));
 2604  4
                                         astFactory.addASTChild(currentAST, tmp60_AST);
 2605  4
                                         match(COMMA);
 2606  4
                                         classOrInterfaceType(false);
 2607  4
                                         astFactory.addASTChild(currentAST, returnAST);
 2608  4
                                 }
 2609  
                                 else {
 2610  
                                         break _loop139;
 2611  
                                 }
 2612  
                                 
 2613  
                         } while (true);
 2614  
                         }
 2615  
                         break;
 2616  
                 }
 2617  
                 case LCURLY:
 2618  
                 {
 2619  612
                         break;
 2620  
                 }
 2621  
                 default:
 2622  
                 {
 2623  0
                         throw new NoViableAltException(LT(1), getFilename());
 2624  
                 }
 2625  
                 }
 2626  
                 }
 2627  640
                 interfaceExtends_AST = (AST)currentAST.root;
 2628  640
                 returnAST = interfaceExtends_AST;
 2629  640
         }
 2630  
         
 2631  
         public final void enumBlock() throws RecognitionException, TokenStreamException {
 2632  
                 
 2633  463
                 returnAST = null;
 2634  463
                 ASTPair currentAST = new ASTPair();
 2635  463
                 AST enumBlock_AST = null;
 2636  
                 
 2637  463
                 AST tmp61_AST = null;
 2638  463
                 tmp61_AST = astFactory.create(LT(1));
 2639  463
                 astFactory.addASTChild(currentAST, tmp61_AST);
 2640  463
                 match(LCURLY);
 2641  
                 {
 2642  463
                 switch ( LA(1)) {
 2643  
                 case IDENT:
 2644  
                 case AT:
 2645  
                 {
 2646  356
                         enumConstant();
 2647  356
                         astFactory.addASTChild(currentAST, returnAST);
 2648  
                         {
 2649  
                         _loop116:
 2650  
                         do {
 2651  749
                                 if ((LA(1)==COMMA) && (LA(2)==IDENT||LA(2)==AT)) {
 2652  393
                                         AST tmp62_AST = null;
 2653  393
                                         tmp62_AST = astFactory.create(LT(1));
 2654  393
                                         astFactory.addASTChild(currentAST, tmp62_AST);
 2655  393
                                         match(COMMA);
 2656  393
                                         enumConstant();
 2657  393
                                         astFactory.addASTChild(currentAST, returnAST);
 2658  393
                                 }
 2659  
                                 else {
 2660  
                                         break _loop116;
 2661  
                                 }
 2662  
                                 
 2663  
                         } while (true);
 2664  
                         }
 2665  
                         {
 2666  356
                         switch ( LA(1)) {
 2667  
                         case COMMA:
 2668  
                         {
 2669  15
                                 AST tmp63_AST = null;
 2670  15
                                 tmp63_AST = astFactory.create(LT(1));
 2671  15
                                 astFactory.addASTChild(currentAST, tmp63_AST);
 2672  15
                                 match(COMMA);
 2673  15
                                 break;
 2674  
                         }
 2675  
                         case SEMI:
 2676  
                         case RCURLY:
 2677  
                         {
 2678  341
                                 break;
 2679  
                         }
 2680  
                         default:
 2681  
                         {
 2682  0
                                 throw new NoViableAltException(LT(1), getFilename());
 2683  
                         }
 2684  
                         }
 2685  
                         }
 2686  
                         break;
 2687  
                 }
 2688  
                 case SEMI:
 2689  
                 case RCURLY:
 2690  
                 {
 2691  107
                         break;
 2692  
                 }
 2693  
                 default:
 2694  
                 {
 2695  0
                         throw new NoViableAltException(LT(1), getFilename());
 2696  
                 }
 2697  
                 }
 2698  
                 }
 2699  
                 {
 2700  463
                 switch ( LA(1)) {
 2701  
                 case SEMI:
 2702  
                 {
 2703  275
                         AST tmp64_AST = null;
 2704  275
                         tmp64_AST = astFactory.create(LT(1));
 2705  275
                         astFactory.addASTChild(currentAST, tmp64_AST);
 2706  275
                         match(SEMI);
 2707  
                         {
 2708  
                         _loop120:
 2709  
                         do {
 2710  838
                                 switch ( LA(1)) {
 2711  
                                 case FINAL:
 2712  
                                 case ABSTRACT:
 2713  
                                 case STRICTFP:
 2714  
                                 case LITERAL_void:
 2715  
                                 case LITERAL_boolean:
 2716  
                                 case LITERAL_byte:
 2717  
                                 case LITERAL_char:
 2718  
                                 case LITERAL_short:
 2719  
                                 case LITERAL_int:
 2720  
                                 case LITERAL_float:
 2721  
                                 case LITERAL_long:
 2722  
                                 case LITERAL_double:
 2723  
                                 case IDENT:
 2724  
                                 case LITERAL_private:
 2725  
                                 case LITERAL_public:
 2726  
                                 case LITERAL_protected:
 2727  
                                 case LITERAL_static:
 2728  
                                 case LITERAL_transient:
 2729  
                                 case LITERAL_native:
 2730  
                                 case LITERAL_synchronized:
 2731  
                                 case LITERAL_volatile:
 2732  
                                 case LITERAL_class:
 2733  
                                 case LITERAL_interface:
 2734  
                                 case LCURLY:
 2735  
                                 case LITERAL_default:
 2736  
                                 case LT:
 2737  
                                 case ENUM:
 2738  
                                 case AT:
 2739  
                                 {
 2740  559
                                         field();
 2741  559
                                         astFactory.addASTChild(currentAST, returnAST);
 2742  559
                                         break;
 2743  
                                 }
 2744  
                                 case SEMI:
 2745  
                                 {
 2746  4
                                         AST tmp65_AST = null;
 2747  4
                                         tmp65_AST = astFactory.create(LT(1));
 2748  4
                                         astFactory.addASTChild(currentAST, tmp65_AST);
 2749  4
                                         match(SEMI);
 2750  4
                                         break;
 2751  
                                 }
 2752  
                                 default:
 2753  
                                 {
 2754  275
                                         break _loop120;
 2755  
                                 }
 2756  
                                 }
 2757  
                         } while (true);
 2758  
                         }
 2759  
                         break;
 2760  
                 }
 2761  
                 case RCURLY:
 2762  
                 {
 2763  188
                         break;
 2764  
                 }
 2765  
                 default:
 2766  
                 {
 2767  0
                         throw new NoViableAltException(LT(1), getFilename());
 2768  
                 }
 2769  
                 }
 2770  
                 }
 2771  463
                 AST tmp66_AST = null;
 2772  463
                 tmp66_AST = astFactory.create(LT(1));
 2773  463
                 astFactory.addASTChild(currentAST, tmp66_AST);
 2774  463
                 match(RCURLY);
 2775  463
                 if ( inputState.guessing==0 ) {
 2776  463
                         enumBlock_AST = (AST)currentAST.root;
 2777  463
                         enumBlock_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(OBJBLOCK,"OBJBLOCK")).add(enumBlock_AST));
 2778  463
                         currentAST.root = enumBlock_AST;
 2779  463
                         currentAST.child = enumBlock_AST!=null &&enumBlock_AST.getFirstChild()!=null ?
 2780  463
                                 enumBlock_AST.getFirstChild() : enumBlock_AST;
 2781  463
                         currentAST.advanceChildToEnd();
 2782  
                 }
 2783  463
                 enumBlock_AST = (AST)currentAST.root;
 2784  463
                 returnAST = enumBlock_AST;
 2785  463
         }
 2786  
         
 2787  
         public final void annotationBlock() throws RecognitionException, TokenStreamException {
 2788  
                 
 2789  591
                 returnAST = null;
 2790  591
                 ASTPair currentAST = new ASTPair();
 2791  591
                 AST annotationBlock_AST = null;
 2792  
                 
 2793  591
                 AST tmp67_AST = null;
 2794  591
                 tmp67_AST = astFactory.create(LT(1));
 2795  591
                 astFactory.addASTChild(currentAST, tmp67_AST);
 2796  591
                 match(LCURLY);
 2797  
                 {
 2798  
                 _loop107:
 2799  
                 do {
 2800  1080
                         switch ( LA(1)) {
 2801  
                         case FINAL:
 2802  
                         case ABSTRACT:
 2803  
                         case STRICTFP:
 2804  
                         case LITERAL_void:
 2805  
                         case LITERAL_boolean:
 2806  
                         case LITERAL_byte:
 2807  
                         case LITERAL_char:
 2808  
                         case LITERAL_short:
 2809  
                         case LITERAL_int:
 2810  
                         case LITERAL_float:
 2811  
                         case LITERAL_long:
 2812  
                         case LITERAL_double:
 2813  
                         case IDENT:
 2814  
                         case LITERAL_private:
 2815  
                         case LITERAL_public:
 2816  
                         case LITERAL_protected:
 2817  
                         case LITERAL_static:
 2818  
                         case LITERAL_transient:
 2819  
                         case LITERAL_native:
 2820  
                         case LITERAL_synchronized:
 2821  
                         case LITERAL_volatile:
 2822  
                         case LITERAL_class:
 2823  
                         case LITERAL_interface:
 2824  
                         case LITERAL_default:
 2825  
                         case ENUM:
 2826  
                         case AT:
 2827  
                         {
 2828  489
                                 annotationField();
 2829  489
                                 astFactory.addASTChild(currentAST, returnAST);
 2830  489
                                 break;
 2831  
                         }
 2832  
                         case SEMI:
 2833  
                         {
 2834  0
                                 AST tmp68_AST = null;
 2835  0
                                 tmp68_AST = astFactory.create(LT(1));
 2836  0
                                 astFactory.addASTChild(currentAST, tmp68_AST);
 2837  0
                                 match(SEMI);
 2838  0
                                 break;
 2839  
                         }
 2840  
                         default:
 2841  
                         {
 2842  591
                                 break _loop107;
 2843  
                         }
 2844  
                         }
 2845  
                 } while (true);
 2846  
                 }
 2847  591
                 AST tmp69_AST = null;
 2848  591
                 tmp69_AST = astFactory.create(LT(1));
 2849  591
                 astFactory.addASTChild(currentAST, tmp69_AST);
 2850  591
                 match(RCURLY);
 2851  591
                 if ( inputState.guessing==0 ) {
 2852  591
                         annotationBlock_AST = (AST)currentAST.root;
 2853  591
                         annotationBlock_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(OBJBLOCK,"OBJBLOCK")).add(annotationBlock_AST));
 2854  591
                         currentAST.root = annotationBlock_AST;
 2855  591
                         currentAST.child = annotationBlock_AST!=null &&annotationBlock_AST.getFirstChild()!=null ?
 2856  591
                                 annotationBlock_AST.getFirstChild() : annotationBlock_AST;
 2857  591
                         currentAST.advanceChildToEnd();
 2858  
                 }
 2859  591
                 annotationBlock_AST = (AST)currentAST.root;
 2860  591
                 returnAST = annotationBlock_AST;
 2861  591
         }
 2862  
         
 2863  
         public final void typeParameter() throws RecognitionException, TokenStreamException {
 2864  
                 
 2865  768
                 returnAST = null;
 2866  768
                 ASTPair currentAST = new ASTPair();
 2867  768
                 AST typeParameter_AST = null;
 2868  768
                 Token  id = null;
 2869  768
                 AST id_AST = null;
 2870  
                 
 2871  
                 {
 2872  768
                 if (((LA(1)==IDENT||LA(1)==AT) && (_tokenSet_18.member(LA(2))))&&(LA(1) == AT)) {
 2873  4
                         annotations();
 2874  4
                         astFactory.addASTChild(currentAST, returnAST);
 2875  
                 }
 2876  764
                 else if ((LA(1)==IDENT) && (_tokenSet_18.member(LA(2)))) {
 2877  
                 }
 2878  
                 else {
 2879  0
                         throw new NoViableAltException(LT(1), getFilename());
 2880  
                 }
 2881  
                 
 2882  
                 }
 2883  
                 {
 2884  768
                 id = LT(1);
 2885  768
                 id_AST = astFactory.create(id);
 2886  768
                 astFactory.addASTChild(currentAST, id_AST);
 2887  768
                 match(IDENT);
 2888  
                 }
 2889  
                 {
 2890  768
                 if ((LA(1)==LITERAL_extends) && (LA(2)==IDENT||LA(2)==AT)) {
 2891  145
                         typeParameterBounds();
 2892  145
                         astFactory.addASTChild(currentAST, returnAST);
 2893  
                 }
 2894  623
                 else if ((_tokenSet_18.member(LA(1))) && (_tokenSet_19.member(LA(2)))) {
 2895  
                 }
 2896  
                 else {
 2897  0
                         throw new NoViableAltException(LT(1), getFilename());
 2898  
                 }
 2899  
                 
 2900  
                 }
 2901  768
                 if ( inputState.guessing==0 ) {
 2902  759
                         typeParameter_AST = (AST)currentAST.root;
 2903  759
                         typeParameter_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(TYPE_PARAMETER,"TYPE_PARAMETER")).add(typeParameter_AST));
 2904  759
                         currentAST.root = typeParameter_AST;
 2905  759
                         currentAST.child = typeParameter_AST!=null &&typeParameter_AST.getFirstChild()!=null ?
 2906  759
                                 typeParameter_AST.getFirstChild() : typeParameter_AST;
 2907  759
                         currentAST.advanceChildToEnd();
 2908  
                 }
 2909  768
                 typeParameter_AST = (AST)currentAST.root;
 2910  768
                 returnAST = typeParameter_AST;
 2911  768
         }
 2912  
         
 2913  
         public final void typeParameterBounds() throws RecognitionException, TokenStreamException {
 2914  
                 
 2915  145
                 returnAST = null;
 2916  145
                 ASTPair currentAST = new ASTPair();
 2917  145
                 AST typeParameterBounds_AST = null;
 2918  145
                 Token  e = null;
 2919  145
                 AST e_AST = null;
 2920  145
                 Token  b = null;
 2921  145
                 AST b_AST = null;
 2922  
                 
 2923  145
                 e = LT(1);
 2924  145
                 e_AST = astFactory.create(e);
 2925  145
                 astFactory.makeASTRoot(currentAST, e_AST);
 2926  145
                 match(LITERAL_extends);
 2927  145
                 classOrInterfaceType(true);
 2928  145
                 astFactory.addASTChild(currentAST, returnAST);
 2929  
                 {
 2930  
                 _loop104:
 2931  
                 do {
 2932  207
                         if ((LA(1)==BAND)) {
 2933  62
                                 b = LT(1);
 2934  62
                                 b_AST = astFactory.create(b);
 2935  62
                                 astFactory.addASTChild(currentAST, b_AST);
 2936  62
                                 match(BAND);
 2937  62
                                 if ( inputState.guessing==0 ) {
 2938  62
                                         b_AST.setType(TYPE_EXTENSION_AND);
 2939  
                                 }
 2940  62
                                 classOrInterfaceType(true);
 2941  62
                                 astFactory.addASTChild(currentAST, returnAST);
 2942  
                         }
 2943  
                         else {
 2944  
                                 break _loop104;
 2945  
                         }
 2946  
                         
 2947  
                 } while (true);
 2948  
                 }
 2949  145
                 if ( inputState.guessing==0 ) {
 2950  145
                         e_AST.setType(TYPE_UPPER_BOUNDS);
 2951  
                 }
 2952  145
                 typeParameterBounds_AST = (AST)currentAST.root;
 2953  145
                 returnAST = typeParameterBounds_AST;
 2954  145
         }
 2955  
         
 2956  
         public final void annotationField() throws RecognitionException, TokenStreamException {
 2957  
                 
 2958  489
                 returnAST = null;
 2959  489
                 ASTPair currentAST = new ASTPair();
 2960  489
                 AST annotationField_AST = null;
 2961  489
                 AST mods_AST = null;
 2962  489
                 AST td_AST = null;
 2963  489
                 AST t_AST = null;
 2964  489
                 Token  i = null;
 2965  489
                 AST i_AST = null;
 2966  489
                 AST rt_AST = null;
 2967  489
                 AST d_AST = null;
 2968  489
                 Token  s = null;
 2969  489
                 AST s_AST = null;
 2970  489
                 AST v_AST = null;
 2971  489
                 Token  s6 = null;
 2972  489
                 AST s6_AST = null;
 2973  
                 
 2974  489
                 modifiers();
 2975  489
                 mods_AST = (AST)returnAST;
 2976  
                 {
 2977  489
                 if ((_tokenSet_20.member(LA(1))) && (LA(2)==IDENT||LA(2)==LITERAL_interface)) {
 2978  19
                         typeDefinitionInternal(mods_AST);
 2979  19
                         td_AST = (AST)returnAST;
 2980  19
                         if ( inputState.guessing==0 ) {
 2981  19
                                 annotationField_AST = (AST)currentAST.root;
 2982  19
                                 annotationField_AST = td_AST;
 2983  19
                                 currentAST.root = annotationField_AST;
 2984  19
                                 currentAST.child = annotationField_AST!=null &&annotationField_AST.getFirstChild()!=null ?
 2985  19
                                         annotationField_AST.getFirstChild() : annotationField_AST;
 2986  19
                                 currentAST.advanceChildToEnd();
 2987  
                         }
 2988  
                 }
 2989  470
                 else if ((_tokenSet_9.member(LA(1))) && (_tokenSet_21.member(LA(2)))) {
 2990  470
                         typeSpec(false);
 2991  470
                         t_AST = (AST)returnAST;
 2992  
                         {
 2993  470
                         if ((LA(1)==IDENT) && (LA(2)==LPAREN)) {
 2994  349
                                 i = LT(1);
 2995  349
                                 i_AST = astFactory.create(i);
 2996  349
                                 match(IDENT);
 2997  349
                                 AST tmp70_AST = null;
 2998  349
                                 tmp70_AST = astFactory.create(LT(1));
 2999  349
                                 match(LPAREN);
 3000  349
                                 AST tmp71_AST = null;
 3001  349
                                 tmp71_AST = astFactory.create(LT(1));
 3002  349
                                 match(RPAREN);
 3003  349
                                 declaratorBrackets(t_AST);
 3004  349
                                 rt_AST = (AST)returnAST;
 3005  
                                 {
 3006  349
                                 switch ( LA(1)) {
 3007  
                                 case LITERAL_default:
 3008  
                                 {
 3009  97
                                         annotationDefault();
 3010  97
                                         d_AST = (AST)returnAST;
 3011  97
                                         break;
 3012  
                                 }
 3013  
                                 case SEMI:
 3014  
                                 {
 3015  252
                                         break;
 3016  
                                 }
 3017  
                                 default:
 3018  
                                 {
 3019  0
                                         throw new NoViableAltException(LT(1), getFilename());
 3020  
                                 }
 3021  
                                 }
 3022  
                                 }
 3023  349
                                 s = LT(1);
 3024  349
                                 s_AST = astFactory.create(s);
 3025  349
                                 match(SEMI);
 3026  349
                                 if ( inputState.guessing==0 ) {
 3027  349
                                         annotationField_AST = (AST)currentAST.root;
 3028  349
                                         annotationField_AST =
 3029  349
                                         (AST)astFactory.make( (new ASTArray(8)).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(tmp70_AST).add(tmp71_AST).add(d_AST).add(s_AST));
 3030  349
                                         currentAST.root = annotationField_AST;
 3031  349
                                         currentAST.child = annotationField_AST!=null &&annotationField_AST.getFirstChild()!=null ?
 3032  349
                                                 annotationField_AST.getFirstChild() : annotationField_AST;
 3033  349
                                         currentAST.advanceChildToEnd();
 3034  
                                 }
 3035  349
                         }
 3036  121
                         else if ((LA(1)==IDENT) && (_tokenSet_22.member(LA(2)))) {
 3037  121
                                 variableDefinitions(mods_AST,t_AST);
 3038  121
                                 v_AST = (AST)returnAST;
 3039  121
                                 s6 = LT(1);
 3040  121
                                 s6_AST = astFactory.create(s6);
 3041  121
                                 match(SEMI);
 3042  121
                                 if ( inputState.guessing==0 ) {
 3043  121
                                         annotationField_AST = (AST)currentAST.root;
 3044  
                                         
 3045  121
                                         annotationField_AST = v_AST;
 3046  121
                                         v_AST.addChild(s6_AST);
 3047  
                                         
 3048  121
                                         currentAST.root = annotationField_AST;
 3049  121
                                         currentAST.child = annotationField_AST!=null &&annotationField_AST.getFirstChild()!=null ?
 3050  121
                                                 annotationField_AST.getFirstChild() : annotationField_AST;
 3051  121
                                         currentAST.advanceChildToEnd();
 3052  
                                 }
 3053  
                         }
 3054  
                         else {
 3055  0
                                 throw new NoViableAltException(LT(1), getFilename());
 3056  
                         }
 3057  
                         
 3058  
                         }
 3059  
                 }
 3060  
                 else {
 3061  0
                         throw new NoViableAltException(LT(1), getFilename());
 3062  
                 }
 3063  
                 
 3064  
                 }
 3065  489
                 returnAST = annotationField_AST;
 3066  489
         }
 3067  
         
 3068  
         public final void declaratorBrackets(
 3069  
                 AST typ
 3070  
         ) throws RecognitionException, TokenStreamException {
 3071  
                 
 3072  50209
                 returnAST = null;
 3073  50209
                 ASTPair currentAST = new ASTPair();
 3074  50209
                 AST declaratorBrackets_AST = null;
 3075  50209
                 Token  lb = null;
 3076  50209
                 AST lb_AST = null;
 3077  
                 
 3078  50209
                 if ( inputState.guessing==0 ) {
 3079  32147
                         declaratorBrackets_AST = (AST)currentAST.root;
 3080  32147
                         declaratorBrackets_AST=typ;
 3081  32147
                         currentAST.root = declaratorBrackets_AST;
 3082  32147
                         currentAST.child = declaratorBrackets_AST!=null &&declaratorBrackets_AST.getFirstChild()!=null ?
 3083  1532
                                 declaratorBrackets_AST.getFirstChild() : declaratorBrackets_AST;
 3084  32147
                         currentAST.advanceChildToEnd();
 3085  
                 }
 3086  
                 {
 3087  
                 _loop169:
 3088  
                 do {
 3089  50384
                         if ((LA(1)==LBRACK)) {
 3090  175
                                 lb = LT(1);
 3091  175
                                 lb_AST = astFactory.create(lb);
 3092  175
                                 astFactory.makeASTRoot(currentAST, lb_AST);
 3093  175
                                 match(LBRACK);
 3094  175
                                 if ( inputState.guessing==0 ) {
 3095  127
                                         lb_AST.setType(ARRAY_DECLARATOR);
 3096  
                                 }
 3097  175
                                 AST tmp72_AST = null;
 3098  175
                                 tmp72_AST = astFactory.create(LT(1));
 3099  175
                                 astFactory.addASTChild(currentAST, tmp72_AST);
 3100  175
                                 match(RBRACK);
 3101  175
                         }
 3102  
                         else {
 3103  
                                 break _loop169;
 3104  
                         }
 3105  
                         
 3106  
                 } while (true);
 3107  
                 }
 3108  50209
                 declaratorBrackets_AST = (AST)currentAST.root;
 3109  50209
                 returnAST = declaratorBrackets_AST;
 3110  50209
         }
 3111  
         
 3112  
         public final void annotationDefault() throws RecognitionException, TokenStreamException {
 3113  
                 
 3114  97
                 returnAST = null;
 3115  97
                 ASTPair currentAST = new ASTPair();
 3116  97
                 AST annotationDefault_AST = null;
 3117  
                 
 3118  97
                 AST tmp73_AST = null;
 3119  97
                 tmp73_AST = astFactory.create(LT(1));
 3120  97
                 astFactory.makeASTRoot(currentAST, tmp73_AST);
 3121  97
                 match(LITERAL_default);
 3122  97
                 annotationMemberValueInitializer();
 3123  97
                 astFactory.addASTChild(currentAST, returnAST);
 3124  97
                 annotationDefault_AST = (AST)currentAST.root;
 3125  97
                 returnAST = annotationDefault_AST;
 3126  97
         }
 3127  
         
 3128  
         public final void enumConstant() throws RecognitionException, TokenStreamException {
 3129  
                 
 3130  749
                 returnAST = null;
 3131  749
                 ASTPair currentAST = new ASTPair();
 3132  749
                 AST enumConstant_AST = null;
 3133  749
                 AST an_AST = null;
 3134  749
                 Token  i = null;
 3135  749
                 AST i_AST = null;
 3136  749
                 Token  l = null;
 3137  749
                 AST l_AST = null;
 3138  749
                 AST args_AST = null;
 3139  749
                 Token  r = null;
 3140  749
                 AST r_AST = null;
 3141  749
                 AST b_AST = null;
 3142  
                 
 3143  749
                 annotations();
 3144  749
                 an_AST = (AST)returnAST;
 3145  749
                 i = LT(1);
 3146  749
                 i_AST = astFactory.create(i);
 3147  749
                 match(IDENT);
 3148  
                 {
 3149  749
                 switch ( LA(1)) {
 3150  
                 case LPAREN:
 3151  
                 {
 3152  135
                         l = LT(1);
 3153  135
                         l_AST = astFactory.create(l);
 3154  135
                         match(LPAREN);
 3155  135
                         argList();
 3156  135
                         args_AST = (AST)returnAST;
 3157  135
                         r = LT(1);
 3158  135
                         r_AST = astFactory.create(r);
 3159  135
                         match(RPAREN);
 3160  135
                         break;
 3161  
                 }
 3162  
                 case SEMI:
 3163  
                 case LCURLY:
 3164  
                 case RCURLY:
 3165  
                 case COMMA:
 3166  
                 {
 3167  614
                         break;
 3168  
                 }
 3169  
                 default:
 3170  
                 {
 3171  0
                         throw new NoViableAltException(LT(1), getFilename());
 3172  
                 }
 3173  
                 }
 3174  
                 }
 3175  
                 {
 3176  749
                 switch ( LA(1)) {
 3177  
                 case LCURLY:
 3178  
                 {
 3179  92
                         enumConstantBlock();
 3180  92
                         b_AST = (AST)returnAST;
 3181  92
                         break;
 3182  
                 }
 3183  
                 case SEMI:
 3184  
                 case RCURLY:
 3185  
                 case COMMA:
 3186  
                 {
 3187  657
                         break;
 3188  
                 }
 3189  
                 default:
 3190  
                 {
 3191  0
                         throw new NoViableAltException(LT(1), getFilename());
 3192  
                 }
 3193  
                 }
 3194  
                 }
 3195  749
                 if ( inputState.guessing==0 ) {
 3196  749
                         enumConstant_AST = (AST)currentAST.root;
 3197  749
                         enumConstant_AST = (AST)astFactory.make( (new ASTArray(7)).add(astFactory.create(ENUM_CONSTANT_DEF,"ENUM_CONSTANT_DEF")).add(an_AST).add(i_AST).add(l_AST).add(args_AST).add(r_AST).add(b_AST));
 3198  749
                         currentAST.root = enumConstant_AST;
 3199  749
                         currentAST.child = enumConstant_AST!=null &&enumConstant_AST.getFirstChild()!=null ?
 3200  749
                                 enumConstant_AST.getFirstChild() : enumConstant_AST;
 3201  749
                         currentAST.advanceChildToEnd();
 3202  
                 }
 3203  749
                 returnAST = enumConstant_AST;
 3204  749
         }
 3205  
         
 3206  
         public final void field() throws RecognitionException, TokenStreamException {
 3207  
                 
 3208  22377
                 returnAST = null;
 3209  22377
                 ASTPair currentAST = new ASTPair();
 3210  22377
                 AST field_AST = null;
 3211  22377
                 AST mods_AST = null;
 3212  22377
                 AST td_AST = null;
 3213  22377
                 AST tp_AST = null;
 3214  22377
                 AST h_AST = null;
 3215  22377
                 AST s_AST = null;
 3216  22377
                 AST t_AST = null;
 3217  22377
                 AST param_AST = null;
 3218  22377
                 AST rt_AST = null;
 3219  22377
                 AST tc_AST = null;
 3220  22377
                 AST s2_AST = null;
 3221  22377
                 Token  s5 = null;
 3222  22377
                 AST s5_AST = null;
 3223  22377
                 AST v_AST = null;
 3224  22377
                 Token  s6 = null;
 3225  22377
                 AST s6_AST = null;
 3226  22377
                 Token  si = null;
 3227  22377
                 AST si_AST = null;
 3228  22377
                 AST s3_AST = null;
 3229  22377
                 AST s4_AST = null;
 3230  
                 
 3231  22377
                 if ((_tokenSet_23.member(LA(1))) && (_tokenSet_24.member(LA(2)))) {
 3232  21710
                         modifiers();
 3233  21710
                         mods_AST = (AST)returnAST;
 3234  
                         {
 3235  21710
                         if ((_tokenSet_20.member(LA(1))) && (LA(2)==IDENT||LA(2)==LITERAL_interface)) {
 3236  2247
                                 typeDefinitionInternal(mods_AST);
 3237  2247
                                 td_AST = (AST)returnAST;
 3238  2247
                                 if ( inputState.guessing==0 ) {
 3239  2247
                                         field_AST = (AST)currentAST.root;
 3240  2247
                                         field_AST = td_AST;
 3241  2247
                                         currentAST.root = field_AST;
 3242  2247
                                         currentAST.child = field_AST!=null &&field_AST.getFirstChild()!=null ?
 3243  2247
                                                 field_AST.getFirstChild() : field_AST;
 3244  2247
                                         currentAST.advanceChildToEnd();
 3245  
                                 }
 3246  
                         }
 3247  19463
                         else if ((_tokenSet_25.member(LA(1))) && (_tokenSet_26.member(LA(2)))) {
 3248  
                                 {
 3249  19463
                                 switch ( LA(1)) {
 3250  
                                 case LT:
 3251  
                                 {
 3252  293
                                         typeParameters();
 3253  293
                                         tp_AST = (AST)returnAST;
 3254  293
                                         break;
 3255  
                                 }
 3256  
                                 case LITERAL_void:
 3257  
                                 case LITERAL_boolean:
 3258  
                                 case LITERAL_byte:
 3259  
                                 case LITERAL_char:
 3260  
                                 case LITERAL_short:
 3261  
                                 case LITERAL_int:
 3262  
                                 case LITERAL_float:
 3263  
                                 case LITERAL_long:
 3264  
                                 case LITERAL_double:
 3265  
                                 case IDENT:
 3266  
                                 case AT:
 3267  
                                 {
 3268  19170
                                         break;
 3269  
                                 }
 3270  
                                 default:
 3271  
                                 {
 3272  0
                                         throw new NoViableAltException(LT(1), getFilename());
 3273  
                                 }
 3274  
                                 }
 3275  
                                 }
 3276  
                                 {
 3277  19463
                                 if ((LA(1)==IDENT) && (LA(2)==LPAREN)) {
 3278  1070
                                         ctorHead();
 3279  1070
                                         h_AST = (AST)returnAST;
 3280  1070
                                         constructorBody();
 3281  1070
                                         s_AST = (AST)returnAST;
 3282  1070
                                         if ( inputState.guessing==0 ) {
 3283  1070
                                                 field_AST = (AST)currentAST.root;
 3284  1070
                                                 field_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));
 3285  1070
                                                 currentAST.root = field_AST;
 3286  1070
                                                 currentAST.child = field_AST!=null &&field_AST.getFirstChild()!=null ?
 3287  1070
                                                         field_AST.getFirstChild() : field_AST;
 3288  1070
                                                 currentAST.advanceChildToEnd();
 3289  
                                         }
 3290  
                                 }
 3291  18393
                                 else if ((_tokenSet_9.member(LA(1))) && (_tokenSet_21.member(LA(2)))) {
 3292  18393
                                         typeSpec(false);
 3293  18393
                                         t_AST = (AST)returnAST;
 3294  
                                         {
 3295  18393
                                         if ((LA(1)==IDENT) && (LA(2)==LPAREN)) {
 3296  11501
                                                 AST tmp74_AST = null;
 3297  11501
                                                 tmp74_AST = astFactory.create(LT(1));
 3298  11501
                                                 match(IDENT);
 3299  11501
                                                 AST tmp75_AST = null;
 3300  11501
                                                 tmp75_AST = astFactory.create(LT(1));
 3301  11501
                                                 match(LPAREN);
 3302  11501
                                                 parameterDeclarationList();
 3303  11501
                                                 param_AST = (AST)returnAST;
 3304  11501
                                                 AST tmp76_AST = null;
 3305  11501
                                                 tmp76_AST = astFactory.create(LT(1));
 3306  11501
                                                 match(RPAREN);
 3307  11501
                                                 declaratorBrackets(t_AST);
 3308  11501
                                                 rt_AST = (AST)returnAST;
 3309  
                                                 {
 3310  11501
                                                 switch ( LA(1)) {
 3311  
                                                 case LITERAL_throws:
 3312  
                                                 {
 3313  728
                                                         throwsClause();
 3314  728
                                                         tc_AST = (AST)returnAST;
 3315  728
                                                         break;
 3316  
                                                 }
 3317  
                                                 case SEMI:
 3318  
                                                 case LCURLY:
 3319  
                                                 {
 3320  10773
                                                         break;
 3321  
                                                 }
 3322  
                                                 default:
 3323  
                                                 {
 3324  0
                                                         throw new NoViableAltException(LT(1), getFilename());
 3325  
                                                 }
 3326  
                                                 }
 3327  
                                                 }
 3328  
                                                 {
 3329  11501
                                                 switch ( LA(1)) {
 3330  
                                                 case LCURLY:
 3331  
                                                 {
 3332  10977
                                                         compoundStatement();
 3333  10977
                                                         s2_AST = (AST)returnAST;
 3334  10977
                                                         break;
 3335  
                                                 }
 3336  
                                                 case SEMI:
 3337  
                                                 {
 3338  524
                                                         s5 = LT(1);
 3339  524
                                                         s5_AST = astFactory.create(s5);
 3340  524
                                                         match(SEMI);
 3341  524
                                                         break;
 3342  
                                                 }
 3343  
                                                 default:
 3344  
                                                 {
 3345  0
                                                         throw new NoViableAltException(LT(1), getFilename());
 3346  
                                                 }
 3347  
                                                 }
 3348  
                                                 }
 3349  11501
                                                 if ( inputState.guessing==0 ) {
 3350  11053
                                                         field_AST = (AST)currentAST.root;
 3351  11053
                                                         field_AST = (AST)astFactory.make( (new ASTArray(11)).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(tmp74_AST).add(tmp75_AST).add(param_AST).add(tmp76_AST).add(tc_AST).add(s2_AST).add(s5_AST));
 3352  11053
                                                         currentAST.root = field_AST;
 3353  11053
                                                         currentAST.child = field_AST!=null &&field_AST.getFirstChild()!=null ?
 3354  11053
                                                                 field_AST.getFirstChild() : field_AST;
 3355  11053
                                                         currentAST.advanceChildToEnd();
 3356  
                                                 }
 3357  11501
                                         }
 3358  6892
                                         else if ((LA(1)==IDENT) && (_tokenSet_27.member(LA(2)))) {
 3359  6892
                                                 variableDefinitions(mods_AST,t_AST);
 3360  6892
                                                 v_AST = (AST)returnAST;
 3361  
                                                 {
 3362  6892
                                                 if ((LA(1)==SEMI) && (_tokenSet_28.member(LA(2)))) {
 3363  6892
                                                         s6 = LT(1);
 3364  6892
                                                         s6_AST = astFactory.create(s6);
 3365  6892
                                                         match(SEMI);
 3366  
                                                 }
 3367  0
                                                 else if ((_tokenSet_28.member(LA(1))) && (_tokenSet_29.member(LA(2)))) {
 3368  
                                                 }
 3369  
                                                 else {
 3370  0
                                                         throw new NoViableAltException(LT(1), getFilename());
 3371  
                                                 }
 3372  
                                                 
 3373  
                                                 }
 3374  6892
                                                 if ( inputState.guessing==0 ) {
 3375  6818
                                                         field_AST = (AST)currentAST.root;
 3376  
                                                         
 3377  6818
                                                         field_AST = v_AST;
 3378  6818
                                                         v_AST.addChild(s6_AST);
 3379  
                                                         
 3380  6818
                                                         currentAST.root = field_AST;
 3381  6818
                                                         currentAST.child = field_AST!=null &&field_AST.getFirstChild()!=null ?
 3382  6818
                                                                 field_AST.getFirstChild() : field_AST;
 3383  6818
                                                         currentAST.advanceChildToEnd();
 3384  
                                                 }
 3385  
                                         }
 3386  
                                         else {
 3387  0
                                                 throw new NoViableAltException(LT(1), getFilename());
 3388  
                                         }
 3389  
                                         
 3390  
                                         }
 3391  
                                 }
 3392  
                                 else {
 3393  0
                                         throw new NoViableAltException(LT(1), getFilename());
 3394  
                                 }
 3395  
                                 
 3396  
                                 }
 3397  
                         }
 3398  
                         else {
 3399  0
                                 throw new NoViableAltException(LT(1), getFilename());
 3400  
                         }
 3401  
                         
 3402  
                         }
 3403  
                 }
 3404  667
                 else if ((LA(1)==LITERAL_static) && (LA(2)==LCURLY)) {
 3405  291
                         si = LT(1);
 3406  291
                         si_AST = astFactory.create(si);
 3407  291
                         match(LITERAL_static);
 3408  291
                         compoundStatement();
 3409  291
                         s3_AST = (AST)returnAST;
 3410  291
                         if ( inputState.guessing==0 ) {
 3411  291
                                 field_AST = (AST)currentAST.root;
 3412  291
                                 si_AST.setType(STATIC_INIT);
 3413  291
                                 si_AST.setText("STATIC_INIT");
 3414  291
                                 field_AST = (AST)astFactory.make( (new ASTArray(2)).add(si_AST).add(s3_AST));
 3415  291
                                 currentAST.root = field_AST;
 3416  291
                                 currentAST.child = field_AST!=null &&field_AST.getFirstChild()!=null ?
 3417  291
                                         field_AST.getFirstChild() : field_AST;
 3418  291
                                 currentAST.advanceChildToEnd();
 3419  
                         }
 3420  
                 }
 3421  376
                 else if ((LA(1)==LCURLY)) {
 3422  376
                         compoundStatement();
 3423  376
                         s4_AST = (AST)returnAST;
 3424  376
                         if ( inputState.guessing==0 ) {
 3425  330
                                 field_AST = (AST)currentAST.root;
 3426  330
                                 field_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(INSTANCE_INIT,"INSTANCE_INIT")).add(s4_AST));
 3427  330
                                 currentAST.root = field_AST;
 3428  330
                                 currentAST.child = field_AST!=null &&field_AST.getFirstChild()!=null ?
 3429  330
                                         field_AST.getFirstChild() : field_AST;
 3430  330
                                 currentAST.advanceChildToEnd();
 3431  
                         }
 3432  
                 }
 3433  
                 else {
 3434  0
                         throw new NoViableAltException(LT(1), getFilename());
 3435  
                 }
 3436  
                 
 3437  22377
                 returnAST = field_AST;
 3438  22377
         }
 3439  
         
 3440  
         public final void argList() throws RecognitionException, TokenStreamException {
 3441  
                 
 3442  19505
                 returnAST = null;
 3443  19505
                 ASTPair currentAST = new ASTPair();
 3444  19505
                 AST argList_AST = null;
 3445  
                 
 3446  
                 {
 3447  19505
                 if (((_tokenSet_12.member(LA(1))))&&(LA(1)!=RPAREN)) {
 3448  9923
                         expressionList();
 3449  9923
                         astFactory.addASTChild(currentAST, returnAST);
 3450  
                 }
 3451  9582
                 else if ((LA(1)==RPAREN)) {
 3452  9582
                         if ( inputState.guessing==0 ) {
 3453  5265
                                 argList_AST = (AST)currentAST.root;
 3454  5265
                                 argList_AST = astFactory.create(ELIST,"ELIST");
 3455  5265
                                 currentAST.root = argList_AST;
 3456  5265
                                 currentAST.child = argList_AST!=null &&argList_AST.getFirstChild()!=null ?
 3457  0
                                         argList_AST.getFirstChild() : argList_AST;
 3458  5265
                                 currentAST.advanceChildToEnd();
 3459  
                         }
 3460  
                 }
 3461  
                 else {
 3462  0
                         throw new NoViableAltException(LT(1), getFilename());
 3463  
                 }
 3464  
                 
 3465  
                 }
 3466  19505
                 argList_AST = (AST)currentAST.root;
 3467  19505
                 returnAST = argList_AST;
 3468  19505
         }
 3469  
         
 3470  
         public final void enumConstantBlock() throws RecognitionException, TokenStreamException {
 3471  
                 
 3472  92
                 returnAST = null;
 3473  92
                 ASTPair currentAST = new ASTPair();
 3474  92
                 AST enumConstantBlock_AST = null;
 3475  
                 
 3476  92
                 AST tmp77_AST = null;
 3477  92
                 tmp77_AST = astFactory.create(LT(1));
 3478  92
                 astFactory.addASTChild(currentAST, tmp77_AST);
 3479  92
                 match(LCURLY);
 3480  
                 {
 3481  
                 _loop126:
 3482  
                 do {
 3483  287
                         switch ( LA(1)) {
 3484  
                         case FINAL:
 3485  
                         case ABSTRACT:
 3486  
                         case STRICTFP:
 3487  
                         case LITERAL_void:
 3488  
                         case LITERAL_boolean:
 3489  
                         case LITERAL_byte:
 3490  
                         case LITERAL_char:
 3491  
                         case LITERAL_short:
 3492  
                         case LITERAL_int:
 3493  
                         case LITERAL_float:
 3494  
                         case LITERAL_long:
 3495  
                         case LITERAL_double:
 3496  
                         case IDENT:
 3497  
                         case LITERAL_private:
 3498  
                         case LITERAL_public:
 3499  
                         case LITERAL_protected:
 3500  
                         case LITERAL_static:
 3501  
                         case LITERAL_transient:
 3502  
                         case LITERAL_native:
 3503  
                         case LITERAL_synchronized:
 3504  
                         case LITERAL_volatile:
 3505  
                         case LITERAL_class:
 3506  
                         case LITERAL_interface:
 3507  
                         case LCURLY:
 3508  
                         case LITERAL_default:
 3509  
                         case LT:
 3510  
                         case ENUM:
 3511  
                         case AT:
 3512  
                         {
 3513  179
                                 enumConstantField();
 3514  179
                                 astFactory.addASTChild(currentAST, returnAST);
 3515  179
                                 break;
 3516  
                         }
 3517  
                         case SEMI:
 3518  
                         {
 3519  16
                                 AST tmp78_AST = null;
 3520  16
                                 tmp78_AST = astFactory.create(LT(1));
 3521  16
                                 astFactory.addASTChild(currentAST, tmp78_AST);
 3522  16
                                 match(SEMI);
 3523  16
                                 break;
 3524  
                         }
 3525  
                         default:
 3526  
                         {
 3527  92
                                 break _loop126;
 3528  
                         }
 3529  
                         }
 3530  
                 } while (true);
 3531  
                 }
 3532  92
                 AST tmp79_AST = null;
 3533  92
                 tmp79_AST = astFactory.create(LT(1));
 3534  92
                 astFactory.addASTChild(currentAST, tmp79_AST);
 3535  92
                 match(RCURLY);
 3536  92
                 if ( inputState.guessing==0 ) {
 3537  92
                         enumConstantBlock_AST = (AST)currentAST.root;
 3538  92
                         enumConstantBlock_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(OBJBLOCK,"OBJBLOCK")).add(enumConstantBlock_AST));
 3539  92
                         currentAST.root = enumConstantBlock_AST;
 3540  92
                         currentAST.child = enumConstantBlock_AST!=null &&enumConstantBlock_AST.getFirstChild()!=null ?
 3541  92
                                 enumConstantBlock_AST.getFirstChild() : enumConstantBlock_AST;
 3542  92
                         currentAST.advanceChildToEnd();
 3543  
                 }
 3544  92
                 enumConstantBlock_AST = (AST)currentAST.root;
 3545  92
                 returnAST = enumConstantBlock_AST;
 3546  92
         }
 3547  
         
 3548  
         public final void enumConstantField() throws RecognitionException, TokenStreamException {
 3549  
                 
 3550  179
                 returnAST = null;
 3551  179
                 ASTPair currentAST = new ASTPair();
 3552  179
                 AST enumConstantField_AST = null;
 3553  179
                 AST mods_AST = null;
 3554  179
                 AST td_AST = null;
 3555  179
                 AST tp_AST = null;
 3556  179
                 AST t_AST = null;
 3557  179
                 AST param_AST = null;
 3558  179
                 AST rt_AST = null;
 3559  179
                 AST tc_AST = null;
 3560  179
                 AST s2_AST = null;
 3561  179
                 Token  s3 = null;
 3562  179
                 AST s3_AST = null;
 3563  179
                 AST v_AST = null;
 3564  179
                 Token  s6 = null;
 3565  179
                 AST s6_AST = null;
 3566  179
                 AST s4_AST = null;
 3567  
                 
 3568  179
                 switch ( LA(1)) {
 3569  
                 case FINAL:
 3570  
                 case ABSTRACT:
 3571  
                 case STRICTFP:
 3572  
                 case LITERAL_void:
 3573  
                 case LITERAL_boolean:
 3574  
                 case LITERAL_byte:
 3575  
                 case LITERAL_char:
 3576  
                 case LITERAL_short:
 3577  
                 case LITERAL_int:
 3578  
                 case LITERAL_float:
 3579  
                 case LITERAL_long:
 3580  
                 case LITERAL_double:
 3581  
                 case IDENT:
 3582  
                 case LITERAL_private:
 3583  
                 case LITERAL_public:
 3584  
                 case LITERAL_protected:
 3585  
                 case LITERAL_static:
 3586  
                 case LITERAL_transient:
 3587  
                 case LITERAL_native:
 3588  
                 case LITERAL_synchronized:
 3589  
                 case LITERAL_volatile:
 3590  
                 case LITERAL_class:
 3591  
                 case LITERAL_interface:
 3592  
                 case LITERAL_default:
 3593  
                 case LT:
 3594  
                 case ENUM:
 3595  
                 case AT:
 3596  
                 {
 3597  175
                         modifiers();
 3598  175
                         mods_AST = (AST)returnAST;
 3599  
                         {
 3600  175
                         if ((_tokenSet_20.member(LA(1))) && (LA(2)==IDENT||LA(2)==LITERAL_interface)) {
 3601  2
                                 typeDefinitionInternal(mods_AST);
 3602  2
                                 td_AST = (AST)returnAST;
 3603  2
                                 if ( inputState.guessing==0 ) {
 3604  2
                                         enumConstantField_AST = (AST)currentAST.root;
 3605  2
                                         enumConstantField_AST = td_AST;
 3606  2
                                         currentAST.root = enumConstantField_AST;
 3607  2
                                         currentAST.child = enumConstantField_AST!=null &&enumConstantField_AST.getFirstChild()!=null ?
 3608  2
                                                 enumConstantField_AST.getFirstChild() : enumConstantField_AST;
 3609  2
                                         currentAST.advanceChildToEnd();
 3610  
                                 }
 3611  
                         }
 3612  173
                         else if ((_tokenSet_25.member(LA(1))) && (_tokenSet_21.member(LA(2)))) {
 3613  
                                 {
 3614  173
                                 switch ( LA(1)) {
 3615  
                                 case LT:
 3616  
                                 {
 3617  40
                                         typeParameters();
 3618  40
                                         tp_AST = (AST)returnAST;
 3619  40
                                         break;
 3620  
                                 }
 3621  
                                 case LITERAL_void:
 3622  
                                 case LITERAL_boolean:
 3623  
                                 case LITERAL_byte:
 3624  
                                 case LITERAL_char:
 3625  
                                 case LITERAL_short:
 3626  
                                 case LITERAL_int:
 3627  
                                 case LITERAL_float:
 3628  
                                 case LITERAL_long:
 3629  
                                 case LITERAL_double:
 3630  
                                 case IDENT:
 3631  
                                 case AT:
 3632  
                                 {
 3633  133
                                         break;
 3634  
                                 }
 3635  
                                 default:
 3636  
                                 {
 3637  0
                                         throw new NoViableAltException(LT(1), getFilename());
 3638  
                                 }
 3639  
                                 }
 3640  
                                 }
 3641  173
                                 typeSpec(false);
 3642  173
                                 t_AST = (AST)returnAST;
 3643  
                                 {
 3644  173
                                 if ((LA(1)==IDENT) && (LA(2)==LPAREN)) {
 3645  131
                                         AST tmp80_AST = null;
 3646  131
                                         tmp80_AST = astFactory.create(LT(1));
 3647  131
                                         match(IDENT);
 3648  131
                                         AST tmp81_AST = null;
 3649  131
                                         tmp81_AST = astFactory.create(LT(1));
 3650  131
                                         match(LPAREN);
 3651  131
                                         parameterDeclarationList();
 3652  131
                                         param_AST = (AST)returnAST;
 3653  131
                                         AST tmp82_AST = null;
 3654  131
                                         tmp82_AST = astFactory.create(LT(1));
 3655  131
                                         match(RPAREN);
 3656  131
                                         declaratorBrackets(t_AST);
 3657  131
                                         rt_AST = (AST)returnAST;
 3658  
                                         {
 3659  131
                                         switch ( LA(1)) {
 3660  
                                         case LITERAL_throws:
 3661  
                                         {
 3662  4
                                                 throwsClause();
 3663  4
                                                 tc_AST = (AST)returnAST;
 3664  4
                                                 break;
 3665  
                                         }
 3666  
                                         case SEMI:
 3667  
                                         case LCURLY:
 3668  
                                         {
 3669  127
                                                 break;
 3670  
                                         }
 3671  
                                         default:
 3672  
                                         {
 3673  0
                                                 throw new NoViableAltException(LT(1), getFilename());
 3674  
                                         }
 3675  
                                         }
 3676  
                                         }
 3677  
                                         {
 3678  131
                                         switch ( LA(1)) {
 3679  
                                         case LCURLY:
 3680  
                                         {
 3681  129
                                                 compoundStatement();
 3682  129
                                                 s2_AST = (AST)returnAST;
 3683  129
                                                 break;
 3684  
                                         }
 3685  
                                         case SEMI:
 3686  
                                         {
 3687  2
                                                 s3 = LT(1);
 3688  2
                                                 s3_AST = astFactory.create(s3);
 3689  2
                                                 match(SEMI);
 3690  2
                                                 break;
 3691  
                                         }
 3692  
                                         default:
 3693  
                                         {
 3694  0
                                                 throw new NoViableAltException(LT(1), getFilename());
 3695  
                                         }
 3696  
                                         }
 3697  
                                         }
 3698  131
                                         if ( inputState.guessing==0 ) {
 3699  131
                                                 enumConstantField_AST = (AST)currentAST.root;
 3700  131
                                                 enumConstantField_AST = (AST)astFactory.make( (new ASTArray(11)).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(tmp80_AST).add(tmp81_AST).add(param_AST).add(tmp82_AST).add(tc_AST).add(s2_AST).add(s3_AST));
 3701  131
                                                 currentAST.root = enumConstantField_AST;
 3702  131
                                                 currentAST.child = enumConstantField_AST!=null &&enumConstantField_AST.getFirstChild()!=null ?
 3703  131
                                                         enumConstantField_AST.getFirstChild() : enumConstantField_AST;
 3704  131
                                                 currentAST.advanceChildToEnd();
 3705  
                                         }
 3706  131
                                 }
 3707  42
                                 else if ((LA(1)==IDENT) && (_tokenSet_22.member(LA(2)))) {
 3708  42
                                         variableDefinitions(mods_AST,t_AST);
 3709  42
                                         v_AST = (AST)returnAST;
 3710  42
                                         s6 = LT(1);
 3711  42
                                         s6_AST = astFactory.create(s6);
 3712  42
                                         match(SEMI);
 3713  42
                                         if ( inputState.guessing==0 ) {
 3714  42
                                                 enumConstantField_AST = (AST)currentAST.root;
 3715  
                                                 
 3716  42
                                                 enumConstantField_AST = v_AST;
 3717  42
                                                 v_AST.addChild(s6_AST);
 3718  
                                                 
 3719  42
                                                 currentAST.root = enumConstantField_AST;
 3720  42
                                                 currentAST.child = enumConstantField_AST!=null &&enumConstantField_AST.getFirstChild()!=null ?
 3721  42
                                                         enumConstantField_AST.getFirstChild() : enumConstantField_AST;
 3722  42
                                                 currentAST.advanceChildToEnd();
 3723  
                                         }
 3724  
                                 }
 3725  
                                 else {
 3726  0
                                         throw new NoViableAltException(LT(1), getFilename());
 3727  
                                 }
 3728  
                                 
 3729  
                                 }
 3730  
                         }
 3731  
                         else {
 3732  0
                                 throw new NoViableAltException(LT(1), getFilename());
 3733  
                         }
 3734  
                         
 3735  
                         }
 3736  
                         break;
 3737  
                 }
 3738  
                 case LCURLY:
 3739  
                 {
 3740  4
                         compoundStatement();
 3741  4
                         s4_AST = (AST)returnAST;
 3742  4
                         if ( inputState.guessing==0 ) {
 3743  4
                                 enumConstantField_AST = (AST)currentAST.root;
 3744  4
                                 enumConstantField_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(INSTANCE_INIT,"INSTANCE_INIT")).add(s4_AST));
 3745  4
                                 currentAST.root = enumConstantField_AST;
 3746  4
                                 currentAST.child = enumConstantField_AST!=null &&enumConstantField_AST.getFirstChild()!=null ?
 3747  4
                                         enumConstantField_AST.getFirstChild() : enumConstantField_AST;
 3748  4
                                 currentAST.advanceChildToEnd();
 3749  
                         }
 3750  
                         break;
 3751  
                 }
 3752  
                 default:
 3753  
                 {
 3754  0
                         throw new NoViableAltException(LT(1), getFilename());
 3755  
                 }
 3756  
                 }
 3757  179
                 returnAST = enumConstantField_AST;
 3758  179
         }
 3759  
         
 3760  
         public final void parameterDeclarationList() throws RecognitionException, TokenStreamException {
 3761  
                 
 3762  14685
                 returnAST = null;
 3763  14685
                 ASTPair currentAST = new ASTPair();
 3764  14685
                 AST parameterDeclarationList_AST = null;
 3765  
                 
 3766  
                 {
 3767  14685
                 boolean synPredMatched188 = false;
 3768  14685
                 if (((_tokenSet_30.member(LA(1))) && (_tokenSet_31.member(LA(2))))) {
 3769  5110
                         int _m188 = mark();
 3770  5110
                         synPredMatched188 = true;
 3771  5110
                         inputState.guessing++;
 3772  
                         try {
 3773  
                                 {
 3774  5110
                                 parameterDeclaration();
 3775  
                                 }
 3776  
                         }
 3777  279
                         catch (RecognitionException pe) {
 3778  279
                                 synPredMatched188 = false;
 3779  4831
                         }
 3780  5110
                         rewind(_m188);
 3781  5110
 inputState.guessing--;
 3782  
                 }
 3783  14685
                 if ( synPredMatched188 ) {
 3784  4831
                         parameterDeclaration();
 3785  4831
                         astFactory.addASTChild(currentAST, returnAST);
 3786  
                         {
 3787  
                         _loop192:
 3788  
                         do {
 3789  6905
                                 boolean synPredMatched191 = false;
 3790  6905
                                 if (((LA(1)==COMMA) && (_tokenSet_30.member(LA(2))))) {
 3791  2078
                                         int _m191 = mark();
 3792  2078
                                         synPredMatched191 = true;
 3793  2078
                                         inputState.guessing++;
 3794  
                                         try {
 3795  
                                                 {
 3796  2078
                                                 match(COMMA);
 3797  2078
                                                 parameterDeclaration();
 3798  
                                                 }
 3799  
                                         }
 3800  4
                                         catch (RecognitionException pe) {
 3801  4
                                                 synPredMatched191 = false;
 3802  2074
                                         }
 3803  2078
                                         rewind(_m191);
 3804  2078
 inputState.guessing--;
 3805  
                                 }
 3806  6905
                                 if ( synPredMatched191 ) {
 3807  2074
                                         AST tmp83_AST = null;
 3808  2074
                                         tmp83_AST = astFactory.create(LT(1));
 3809  2074
                                         astFactory.addASTChild(currentAST, tmp83_AST);
 3810  2074
                                         match(COMMA);
 3811  2074
                                         parameterDeclaration();
 3812  2074
                                         astFactory.addASTChild(currentAST, returnAST);
 3813  
                                 }
 3814  
                                 else {
 3815  
                                         break _loop192;
 3816  
                                 }
 3817  
                                 
 3818  2074
                         } while (true);
 3819  
                         }
 3820  
                         {
 3821  4831
                         switch ( LA(1)) {
 3822  
                         case COMMA:
 3823  
                         {
 3824  4
                                 AST tmp84_AST = null;
 3825  4
                                 tmp84_AST = astFactory.create(LT(1));
 3826  4
                                 astFactory.addASTChild(currentAST, tmp84_AST);
 3827  4
                                 match(COMMA);
 3828  4
                                 variableLengthParameterDeclaration();
 3829  4
                                 astFactory.addASTChild(currentAST, returnAST);
 3830  4
                                 break;
 3831  
                         }
 3832  
                         case RPAREN:
 3833  
                         {
 3834  4810
                                 break;
 3835  
                         }
 3836  
                         default:
 3837  
                         {
 3838  17
                                 throw new NoViableAltException(LT(1), getFilename());
 3839  
                         }
 3840  
                         }
 3841  
                         }
 3842  
                 }
 3843  9854
                 else if ((_tokenSet_32.member(LA(1))) && (_tokenSet_33.member(LA(2)))) {
 3844  178
                         variableLengthParameterDeclaration();
 3845  88
                         astFactory.addASTChild(currentAST, returnAST);
 3846  
                 }
 3847  9676
                 else if ((LA(1)==RPAREN)) {
 3848  
                 }
 3849  
                 else {
 3850  197
                         throw new NoViableAltException(LT(1), getFilename());
 3851  
                 }
 3852  
                 
 3853  
                 }
 3854  14381
                 if ( inputState.guessing==0 ) {
 3855  12636
                         parameterDeclarationList_AST = (AST)currentAST.root;
 3856  12636
                         parameterDeclarationList_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(PARAMETERS,"PARAMETERS")).add(parameterDeclarationList_AST));
 3857  12636
                         currentAST.root = parameterDeclarationList_AST;
 3858  12636
                         currentAST.child = parameterDeclarationList_AST!=null &&parameterDeclarationList_AST.getFirstChild()!=null ?
 3859  3892
                                 parameterDeclarationList_AST.getFirstChild() : parameterDeclarationList_AST;
 3860  12636
                         currentAST.advanceChildToEnd();
 3861  
                 }
 3862  14381
                 parameterDeclarationList_AST = (AST)currentAST.root;
 3863  14381
                 returnAST = parameterDeclarationList_AST;
 3864  14381
         }
 3865  
         
 3866  
         public final void throwsClause() throws RecognitionException, TokenStreamException {
 3867  
                 
 3868  751
                 returnAST = null;
 3869  751
                 ASTPair currentAST = new ASTPair();
 3870  751
                 AST throwsClause_AST = null;
 3871  
                 
 3872  751
                 AST tmp85_AST = null;
 3873  751
                 tmp85_AST = astFactory.create(LT(1));
 3874  751
                 astFactory.makeASTRoot(currentAST, tmp85_AST);
 3875  751
                 match(LITERAL_throws);
 3876  
                 {
 3877  751
                 if (((LA(1)==IDENT||LA(1)==AT) && (_tokenSet_34.member(LA(2))))&&(LA(1) == AT)) {
 3878  9
                         annotations();
 3879  9
                         astFactory.addASTChild(currentAST, returnAST);
 3880  
                 }
 3881  742
                 else if ((LA(1)==IDENT) && (_tokenSet_35.member(LA(2)))) {
 3882  
                 }
 3883  
                 else {
 3884  0
                         throw new NoViableAltException(LT(1), getFilename());
 3885  
                 }
 3886  
                 
 3887  
                 }
 3888  751
                 identifier();
 3889  751
                 astFactory.addASTChild(currentAST, returnAST);
 3890  
                 {
 3891  
                 _loop184:
 3892  
                 do {
 3893  942
                         if ((LA(1)==COMMA)) {
 3894  191
                                 AST tmp86_AST = null;
 3895  191
                                 tmp86_AST = astFactory.create(LT(1));
 3896  191
                                 astFactory.addASTChild(currentAST, tmp86_AST);
 3897  191
                                 match(COMMA);
 3898  
                                 {
 3899  191
                                 if (((LA(1)==IDENT||LA(1)==AT) && (_tokenSet_34.member(LA(2))))&&(LA(1) == AT)) {
 3900  4
                                         annotations();
 3901  4
                                         astFactory.addASTChild(currentAST, returnAST);
 3902  
                                 }
 3903  187
                                 else if ((LA(1)==IDENT) && (_tokenSet_35.member(LA(2)))) {
 3904  
                                 }
 3905  
                                 else {
 3906  0
                                         throw new NoViableAltException(LT(1), getFilename());
 3907  
                                 }
 3908  
                                 
 3909  
                                 }
 3910  191
                                 identifier();
 3911  191
                                 astFactory.addASTChild(currentAST, returnAST);
 3912  191
                         }
 3913  
                         else {
 3914  
                                 break _loop184;
 3915  
                         }
 3916  
                         
 3917  
                 } while (true);
 3918  
                 }
 3919  751
                 throwsClause_AST = (AST)currentAST.root;
 3920  751
                 returnAST = throwsClause_AST;
 3921  751
         }
 3922  
         
 3923  
         public final void compoundStatement() throws RecognitionException, TokenStreamException {
 3924  
                 
 3925  20860
                 returnAST = null;
 3926  20860
                 ASTPair currentAST = new ASTPair();
 3927  20860
                 AST compoundStatement_AST = null;
 3928  20860
                 Token  lc = null;
 3929  20860
                 AST lc_AST = null;
 3930  
                 
 3931  20860
                 lc = LT(1);
 3932  20860
                 lc_AST = astFactory.create(lc);
 3933  20860
                 astFactory.makeASTRoot(currentAST, lc_AST);
 3934  20860
                 match(LCURLY);
 3935  20860
                 if ( inputState.guessing==0 ) {
 3936  19573
                         lc_AST.setType(SLIST);
 3937  
                 }
 3938  
                 {
 3939  
                 _loop212:
 3940  
                 do {
 3941  45701
                         if ((_tokenSet_36.member(LA(1)))) {
 3942  24841
                                 statement();
 3943  24841
                                 astFactory.addASTChild(currentAST, returnAST);
 3944  
                         }
 3945  
                         else {
 3946  
                                 break _loop212;
 3947  
                         }
 3948  
                         
 3949  
                 } while (true);
 3950  
                 }
 3951  20860
                 AST tmp87_AST = null;
 3952  20860
                 tmp87_AST = astFactory.create(LT(1));
 3953  20860
                 astFactory.addASTChild(currentAST, tmp87_AST);
 3954  20860
                 match(RCURLY);
 3955  20860
                 compoundStatement_AST = (AST)currentAST.root;
 3956  20860
                 returnAST = compoundStatement_AST;
 3957  20860
         }
 3958  
         
 3959  
         public final void ctorHead() throws RecognitionException, TokenStreamException {
 3960  
                 
 3961  1070
                 returnAST = null;
 3962  1070
                 ASTPair currentAST = new ASTPair();
 3963  1070
                 AST ctorHead_AST = null;
 3964  
                 
 3965  1070
                 AST tmp88_AST = null;
 3966  1070
                 tmp88_AST = astFactory.create(LT(1));
 3967  1070
                 astFactory.addASTChild(currentAST, tmp88_AST);
 3968  1070
                 match(IDENT);
 3969  1070
                 AST tmp89_AST = null;
 3970  1070
                 tmp89_AST = astFactory.create(LT(1));
 3971  1070
                 astFactory.addASTChild(currentAST, tmp89_AST);
 3972  1070
                 match(LPAREN);
 3973  1070
                 parameterDeclarationList();
 3974  1070
                 astFactory.addASTChild(currentAST, returnAST);
 3975  1070
                 AST tmp90_AST = null;
 3976  1070
                 tmp90_AST = astFactory.create(LT(1));
 3977  1070
                 astFactory.addASTChild(currentAST, tmp90_AST);
 3978  1070
                 match(RPAREN);
 3979  
                 {
 3980  1070
                 switch ( LA(1)) {
 3981  
                 case LITERAL_throws:
 3982  
                 {
 3983  19
                         throwsClause();
 3984  19
                         astFactory.addASTChild(currentAST, returnAST);
 3985  19
                         break;
 3986  
                 }
 3987  
                 case LCURLY:
 3988  
                 {
 3989  1051
                         break;
 3990  
                 }
 3991  
                 default:
 3992  
                 {
 3993  0
                         throw new NoViableAltException(LT(1), getFilename());
 3994  
                 }
 3995  
                 }
 3996  
                 }
 3997  1070
                 ctorHead_AST = (AST)currentAST.root;
 3998  1070
                 returnAST = ctorHead_AST;
 3999  1070
         }
 4000  
         
 4001  
         public final void constructorBody() throws RecognitionException, TokenStreamException {
 4002  
                 
 4003  1070
                 returnAST = null;
 4004  1070
                 ASTPair currentAST = new ASTPair();
 4005  1070
                 AST constructorBody_AST = null;
 4006  1070
                 Token  lc = null;
 4007  1070
                 AST lc_AST = null;
 4008  
                 
 4009  1070
                 lc = LT(1);
 4010  1070
                 lc_AST = astFactory.create(lc);
 4011  1070
                 astFactory.makeASTRoot(currentAST, lc_AST);
 4012  1070
                 match(LCURLY);
 4013  1070
                 if ( inputState.guessing==0 ) {
 4014  1070
                         lc_AST.setType(SLIST);
 4015  
                 }
 4016  
                 {
 4017  1070
                 boolean synPredMatched155 = false;
 4018  1070
                 if (((_tokenSet_37.member(LA(1))) && (_tokenSet_38.member(LA(2))))) {
 4019  291
                         int _m155 = mark();
 4020  291
                         synPredMatched155 = true;
 4021  291
                         inputState.guessing++;
 4022  
                         try {
 4023  
                                 {
 4024  291
                                 explicitConstructorInvocation();
 4025  
                                 }
 4026  
                         }
 4027  203
                         catch (RecognitionException pe) {
 4028  203
                                 synPredMatched155 = false;
 4029  88
                         }
 4030  291
                         rewind(_m155);
 4031  291
 inputState.guessing--;
 4032  
                 }
 4033  1070
                 if ( synPredMatched155 ) {
 4034  88
                         explicitConstructorInvocation();
 4035  88
                         astFactory.addASTChild(currentAST, returnAST);
 4036  
                 }
 4037  982
                 else if ((_tokenSet_39.member(LA(1))) && (_tokenSet_40.member(LA(2)))) {
 4038  
                 }
 4039  
                 else {
 4040  0
                         throw new NoViableAltException(LT(1), getFilename());
 4041  
                 }
 4042  
                 
 4043  
                 }
 4044  
                 {
 4045  
                 _loop157:
 4046  
                 do {
 4047  1845
                         if ((_tokenSet_36.member(LA(1)))) {
 4048  775
                                 statement();
 4049  775
                                 astFactory.addASTChild(currentAST, returnAST);
 4050  
                         }
 4051  
                         else {
 4052  
                                 break _loop157;
 4053  
                         }
 4054  
                         
 4055  
                 } while (true);
 4056  
                 }
 4057  1070
                 AST tmp91_AST = null;
 4058  1070
                 tmp91_AST = astFactory.create(LT(1));
 4059  1070
                 astFactory.addASTChild(currentAST, tmp91_AST);
 4060  1070
                 match(RCURLY);
 4061  1070
                 constructorBody_AST = (AST)currentAST.root;
 4062  1070
                 returnAST = constructorBody_AST;
 4063  1070
         }
 4064  
         
 4065  
         public final void explicitConstructorInvocation() throws RecognitionException, TokenStreamException {
 4066  
                 
 4067  379
                 returnAST = null;
 4068  379
                 ASTPair currentAST = new ASTPair();
 4069  379
                 AST explicitConstructorInvocation_AST = null;
 4070  379
                 Token  t = null;
 4071  379
                 AST t_AST = null;
 4072  379
                 Token  s = null;
 4073  379
                 AST s_AST = null;
 4074  379
                 Token  s1 = null;
 4075  379
                 AST s1_AST = null;
 4076  
                 
 4077  
                 {
 4078  379
                 if ((_tokenSet_41.member(LA(1))) && (_tokenSet_42.member(LA(2)))) {
 4079  
                         {
 4080  168
                         switch ( LA(1)) {
 4081  
                         case LT:
 4082  
                         {
 4083  4
                                 typeArguments(false);
 4084  4
                                 astFactory.addASTChild(currentAST, returnAST);
 4085  4
                                 break;
 4086  
                         }
 4087  
                         case LITERAL_this:
 4088  
                         case LITERAL_super:
 4089  
                         {
 4090  164
                                 break;
 4091  
                         }
 4092  
                         default:
 4093  
                         {
 4094  0
                                 throw new NoViableAltException(LT(1), getFilename());
 4095  
                         }
 4096  
                         }
 4097  
                         }
 4098  
                         {
 4099  168
                         switch ( LA(1)) {
 4100  
                         case LITERAL_this:
 4101  
                         {
 4102  46
                                 t = LT(1);
 4103  46
                                 t_AST = astFactory.create(t);
 4104  46
                                 astFactory.makeASTRoot(currentAST, t_AST);
 4105  46
                                 match(LITERAL_this);
 4106  46
                                 AST tmp92_AST = null;
 4107  46
                                 tmp92_AST = astFactory.create(LT(1));
 4108  46
                                 astFactory.addASTChild(currentAST, tmp92_AST);
 4109  46
                                 match(LPAREN);
 4110  46
                                 argList();
 4111  46
                                 astFactory.addASTChild(currentAST, returnAST);
 4112  46
                                 AST tmp93_AST = null;
 4113  46
                                 tmp93_AST = astFactory.create(LT(1));
 4114  46
                                 astFactory.addASTChild(currentAST, tmp93_AST);
 4115  46
                                 match(RPAREN);
 4116  46
                                 AST tmp94_AST = null;
 4117  46
                                 tmp94_AST = astFactory.create(LT(1));
 4118  46
                                 astFactory.addASTChild(currentAST, tmp94_AST);
 4119  46
                                 match(SEMI);
 4120  46
                                 if ( inputState.guessing==0 ) {
 4121  23
                                         t_AST.setType(CTOR_CALL);
 4122  
                                 }
 4123  
                                 break;
 4124  
                         }
 4125  
                         case LITERAL_super:
 4126  
                         {
 4127  122
                                 s = LT(1);
 4128  122
                                 s_AST = astFactory.create(s);
 4129  122
                                 astFactory.makeASTRoot(currentAST, s_AST);
 4130  122
                                 match(LITERAL_super);
 4131  122
                                 AST tmp95_AST = null;
 4132  122
                                 tmp95_AST = astFactory.create(LT(1));
 4133  122
                                 astFactory.addASTChild(currentAST, tmp95_AST);
 4134  122
                                 match(LPAREN);
 4135  122
                                 argList();
 4136  122
                                 astFactory.addASTChild(currentAST, returnAST);
 4137  122
                                 AST tmp96_AST = null;
 4138  122
                                 tmp96_AST = astFactory.create(LT(1));
 4139  122
                                 astFactory.addASTChild(currentAST, tmp96_AST);
 4140  122
                                 match(RPAREN);
 4141  122
                                 AST tmp97_AST = null;
 4142  122
                                 tmp97_AST = astFactory.create(LT(1));
 4143  122
                                 astFactory.addASTChild(currentAST, tmp97_AST);
 4144  122
                                 match(SEMI);
 4145  122
                                 if ( inputState.guessing==0 ) {
 4146  61
                                         s_AST.setType(SUPER_CTOR_CALL);
 4147  
                                 }
 4148  
                                 break;
 4149  
                         }
 4150  
                         default:
 4151  
                         {
 4152  0
                                 throw new NoViableAltException(LT(1), getFilename());
 4153  
                         }
 4154  
                         }
 4155  
                         }
 4156  
                 }
 4157  211
                 else if ((_tokenSet_43.member(LA(1))) && (_tokenSet_44.member(LA(2)))) {
 4158  211
                         primaryExpression();
 4159  211
                         astFactory.addASTChild(currentAST, returnAST);
 4160  211
                         AST tmp98_AST = null;
 4161  211
                         tmp98_AST = astFactory.create(LT(1));
 4162  211
                         astFactory.addASTChild(currentAST, tmp98_AST);
 4163  211
                         match(DOT);
 4164  
                         {
 4165  87
                         switch ( LA(1)) {
 4166  
                         case LT:
 4167  
                         {
 4168  4
                                 typeArguments(false);
 4169  4
                                 astFactory.addASTChild(currentAST, returnAST);
 4170  4
                                 break;
 4171  
                         }
 4172  
                         case LITERAL_super:
 4173  
                         {
 4174  4
                                 break;
 4175  
                         }
 4176  
                         default:
 4177  
                         {
 4178  79
                                 throw new NoViableAltException(LT(1), getFilename());
 4179  
                         }
 4180  
                         }
 4181  
                         }
 4182  8
                         s1 = LT(1);
 4183  8
                         s1_AST = astFactory.create(s1);
 4184  8
                         astFactory.makeASTRoot(currentAST, s1_AST);
 4185  8
                         match(LITERAL_super);
 4186  8
                         AST tmp99_AST = null;
 4187  8
                         tmp99_AST = astFactory.create(LT(1));
 4188  8
                         astFactory.addASTChild(currentAST, tmp99_AST);
 4189  8
                         match(LPAREN);
 4190  8
                         argList();
 4191  8
                         astFactory.addASTChild(currentAST, returnAST);
 4192  8
                         AST tmp100_AST = null;
 4193  8
                         tmp100_AST = astFactory.create(LT(1));
 4194  8
                         astFactory.addASTChild(currentAST, tmp100_AST);
 4195  8
                         match(RPAREN);
 4196  8
                         AST tmp101_AST = null;
 4197  8
                         tmp101_AST = astFactory.create(LT(1));
 4198  8
                         astFactory.addASTChild(currentAST, tmp101_AST);
 4199  8
                         match(SEMI);
 4200  8
                         if ( inputState.guessing==0 ) {
 4201  4
                                 s1_AST.setType(SUPER_CTOR_CALL);
 4202  
                         }
 4203  8
                 }
 4204  
                 else {
 4205  0
                         throw new NoViableAltException(LT(1), getFilename());
 4206  
                 }
 4207  
                 
 4208  
                 }
 4209  176
                 explicitConstructorInvocation_AST = (AST)currentAST.root;
 4210  176
                 returnAST = explicitConstructorInvocation_AST;
 4211  176
         }
 4212  
         
 4213  
         public final void statement() throws RecognitionException, TokenStreamException {
 4214  
                 
 4215  35277
                 returnAST = null;
 4216  35277
                 ASTPair currentAST = new ASTPair();
 4217  35277
                 AST statement_AST = null;
 4218  
                 
 4219  35277
                 switch ( LA(1)) {
 4220  
                 case FINAL:
 4221  
                 case ABSTRACT:
 4222  
                 case STRICTFP:
 4223  
                 case SEMI:
 4224  
                 case LITERAL_void:
 4225  
                 case LITERAL_boolean:
 4226  
                 case LITERAL_byte:
 4227  
                 case LITERAL_char:
 4228  
                 case LITERAL_short:
 4229  
                 case LITERAL_int:
 4230  
                 case LITERAL_float:
 4231  
                 case LITERAL_long:
 4232  
                 case LITERAL_double:
 4233  
                 case IDENT:
 4234  
                 case LITERAL_private:
 4235  
                 case LITERAL_public:
 4236  
                 case LITERAL_protected:
 4237  
                 case LITERAL_static:
 4238  
                 case LITERAL_transient:
 4239  
                 case LITERAL_native:
 4240  
                 case LITERAL_synchronized:
 4241  
                 case LITERAL_volatile:
 4242  
                 case LITERAL_class:
 4243  
                 case LCURLY:
 4244  
                 case LPAREN:
 4245  
                 case LITERAL_this:
 4246  
                 case LITERAL_super:
 4247  
                 case LITERAL_if:
 4248  
                 case LITERAL_while:
 4249  
                 case LITERAL_do:
 4250  
                 case LITERAL_break:
 4251  
                 case LITERAL_continue:
 4252  
                 case LITERAL_return:
 4253  
                 case LITERAL_switch:
 4254  
                 case LITERAL_throw:
 4255  
                 case LITERAL_for:
 4256  
                 case LITERAL_default:
 4257  
                 case LITERAL_try:
 4258  
                 case PLUS:
 4259  
                 case MINUS:
 4260  
                 case INC:
 4261  
                 case DEC:
 4262  
                 case BNOT:
 4263  
                 case LNOT:
 4264  
                 case LITERAL_true:
 4265  
                 case LITERAL_false:
 4266  
                 case LITERAL_null:
 4267  
                 case LITERAL_new:
 4268  
                 case NUM_INT:
 4269  
                 case CHAR_LITERAL:
 4270  
                 case STRING_LITERAL:
 4271  
                 case NUM_FLOAT:
 4272  
                 case NUM_LONG:
 4273  
                 case NUM_DOUBLE:
 4274  
                 case AT:
 4275  
                 {
 4276  35105
                         traditionalStatement();
 4277  35105
                         astFactory.addASTChild(currentAST, returnAST);
 4278  35105
                         statement_AST = (AST)currentAST.root;
 4279  35105
                         break;
 4280  
                 }
 4281  
                 case ASSERT:
 4282  
                 {
 4283  172
                         assertStatement();
 4284  172
                         astFactory.addASTChild(currentAST, returnAST);
 4285  172
                         statement_AST = (AST)currentAST.root;
 4286  172
                         break;
 4287  
                 }
 4288  
                 default:
 4289  
                 {
 4290  0
                         throw new NoViableAltException(LT(1), getFilename());
 4291  
                 }
 4292  
                 }
 4293  35277
                 returnAST = statement_AST;
 4294  35277
         }
 4295  
         
 4296  
         public final void primaryExpression() throws RecognitionException, TokenStreamException {
 4297  
                 
 4298  223111
                 returnAST = null;
 4299  223111
                 ASTPair currentAST = new ASTPair();
 4300  223111
                 AST primaryExpression_AST = null;
 4301  223111
                 Token  lbt = null;
 4302  223111
                 AST lbt_AST = null;
 4303  
                 
 4304  223111
                 switch ( LA(1)) {
 4305  
                 case NUM_INT:
 4306  
                 case CHAR_LITERAL:
 4307  
                 case STRING_LITERAL:
 4308  
                 case NUM_FLOAT:
 4309  
                 case NUM_LONG:
 4310  
                 case NUM_DOUBLE:
 4311  
                 {
 4312  172480
                         constant();
 4313  172480
                         astFactory.addASTChild(currentAST, returnAST);
 4314  172480
                         primaryExpression_AST = (AST)currentAST.root;
 4315  172480
                         break;
 4316  
                 }
 4317  
                 case LITERAL_true:
 4318  
                 {
 4319  3644
                         AST tmp102_AST = null;
 4320  3644
                         tmp102_AST = astFactory.create(LT(1));
 4321  3644
                         astFactory.addASTChild(currentAST, tmp102_AST);
 4322  3644
                         match(LITERAL_true);
 4323  3644
                         primaryExpression_AST = (AST)currentAST.root;
 4324  3644
                         break;
 4325  
                 }
 4326  
                 case LITERAL_false:
 4327  
                 {
 4328  1408
                         AST tmp103_AST = null;
 4329  1408
                         tmp103_AST = astFactory.create(LT(1));
 4330  1408
                         astFactory.addASTChild(currentAST, tmp103_AST);
 4331  1408
                         match(LITERAL_false);
 4332  1408
                         primaryExpression_AST = (AST)currentAST.root;
 4333  1408
                         break;
 4334  
                 }
 4335  
                 case LITERAL_this:
 4336  
                 {
 4337  1442
                         AST tmp104_AST = null;
 4338  1442
                         tmp104_AST = astFactory.create(LT(1));
 4339  1442
                         astFactory.addASTChild(currentAST, tmp104_AST);
 4340  1442
                         match(LITERAL_this);
 4341  1442
                         primaryExpression_AST = (AST)currentAST.root;
 4342  1442
                         break;
 4343  
                 }
 4344  
                 case LITERAL_null:
 4345  
                 {
 4346  1697
                         AST tmp105_AST = null;
 4347  1697
                         tmp105_AST = astFactory.create(LT(1));
 4348  1697
                         astFactory.addASTChild(currentAST, tmp105_AST);
 4349  1697
                         match(LITERAL_null);
 4350  1697
                         primaryExpression_AST = (AST)currentAST.root;
 4351  1697
                         break;
 4352  
                 }
 4353  
                 case LITERAL_new:
 4354  
                 {
 4355  5456
                         newExpression();
 4356  5456
                         astFactory.addASTChild(currentAST, returnAST);
 4357  5456
                         primaryExpression_AST = (AST)currentAST.root;
 4358  5456
                         break;
 4359  
                 }
 4360  
                 case LPAREN:
 4361  
                 {
 4362  2125
                         AST tmp106_AST = null;
 4363  2125
                         tmp106_AST = astFactory.create(LT(1));
 4364  2125
                         astFactory.addASTChild(currentAST, tmp106_AST);
 4365  2125
                         match(LPAREN);
 4366  
                         {
 4367  2125
                         boolean synPredMatched355 = false;
 4368  2125
                         if (((LA(1)==IDENT||LA(1)==LPAREN) && (_tokenSet_15.member(LA(2))))) {
 4369  176
                                 int _m355 = mark();
 4370  176
                                 synPredMatched355 = true;
 4371  176
                                 inputState.guessing++;
 4372  
                                 try {
 4373  
                                         {
 4374  176
                                         lambdaExpression();
 4375  
                                         }
 4376  
                                 }
 4377  160
                                 catch (RecognitionException pe) {
 4378  160
                                         synPredMatched355 = false;
 4379  16
                                 }
 4380  176
                                 rewind(_m355);
 4381  176
 inputState.guessing--;
 4382  
                         }
 4383  2125
                         if ( synPredMatched355 ) {
 4384  16
                                 lambdaExpression();
 4385  16
                                 astFactory.addASTChild(currentAST, returnAST);
 4386  
                         }
 4387  2109
                         else if ((_tokenSet_12.member(LA(1))) && (_tokenSet_45.member(LA(2)))) {
 4388  2105
                                 assignmentExpression();
 4389  2105
                                 astFactory.addASTChild(currentAST, returnAST);
 4390  
                         }
 4391  
                         else {
 4392  4
                                 throw new NoViableAltException(LT(1), getFilename());
 4393  
                         }
 4394  
                         
 4395  
                         }
 4396  2121
                         AST tmp107_AST = null;
 4397  2121
                         tmp107_AST = astFactory.create(LT(1));
 4398  2121
                         astFactory.addASTChild(currentAST, tmp107_AST);
 4399  2121
                         match(RPAREN);
 4400  2121
                         primaryExpression_AST = (AST)currentAST.root;
 4401  2121
                         break;
 4402  
                 }
 4403  
                 case LITERAL_super:
 4404  
                 {
 4405  202
                         AST tmp108_AST = null;
 4406  202
                         tmp108_AST = astFactory.create(LT(1));
 4407  202
                         astFactory.addASTChild(currentAST, tmp108_AST);
 4408  202
                         match(LITERAL_super);
 4409  202
                         primaryExpression_AST = (AST)currentAST.root;
 4410  202
                         break;
 4411  
                 }
 4412  
                 default:
 4413  34657
                         boolean synPredMatched352 = false;
 4414  34657
                         if (((_tokenSet_9.member(LA(1))) && (_tokenSet_17.member(LA(2))))) {
 4415  34657
                                 int _m352 = mark();
 4416  34657
                                 synPredMatched352 = true;
 4417  34657
                                 inputState.guessing++;
 4418  
                                 try {
 4419  
                                         {
 4420  34657
                                         typeSpec(false);
 4421  34424
                                         match(DOUBLE_COLON);
 4422  
                                         }
 4423  
                                 }
 4424  34441
                                 catch (RecognitionException pe) {
 4425  34441
                                         synPredMatched352 = false;
 4426  216
                                 }
 4427  34657
                                 rewind(_m352);
 4428  34657
 inputState.guessing--;
 4429  
                         }
 4430  34657
                         if ( synPredMatched352 ) {
 4431  216
                                 typeSpec(false);
 4432  216
                                 astFactory.addASTChild(currentAST, returnAST);
 4433  216
                                 primaryExpression_AST = (AST)currentAST.root;
 4434  
                         }
 4435  34441
                         else if ((LA(1)==IDENT) && (_tokenSet_17.member(LA(2)))) {
 4436  34173
                                 AST tmp109_AST = null;
 4437  34173
                                 tmp109_AST = astFactory.create(LT(1));
 4438  34173
                                 astFactory.addASTChild(currentAST, tmp109_AST);
 4439  34173
                                 match(IDENT);
 4440  34173
                                 primaryExpression_AST = (AST)currentAST.root;
 4441  34173
                         }
 4442  268
                         else if (((LA(1) >= LITERAL_void && LA(1) <= LITERAL_double)) && (_tokenSet_17.member(LA(2)))) {
 4443  198
                                 builtInType();
 4444  198
                                 astFactory.addASTChild(currentAST, returnAST);
 4445  
                                 {
 4446  
                                 _loop357:
 4447  
                                 do {
 4448  244
                                         if ((LA(1)==LBRACK) && (LA(2)==RBRACK)) {
 4449  46
                                                 lbt = LT(1);
 4450  46
                                                 lbt_AST = astFactory.create(lbt);
 4451  46
                                                 astFactory.makeASTRoot(currentAST, lbt_AST);
 4452  46
                                                 match(LBRACK);
 4453  46
                                                 if ( inputState.guessing==0 ) {
 4454  24
                                                         lbt_AST.setType(ARRAY_DECLARATOR);
 4455  
                                                 }
 4456  46
                                                 AST tmp110_AST = null;
 4457  46
                                                 tmp110_AST = astFactory.create(LT(1));
 4458  46
                                                 astFactory.addASTChild(currentAST, tmp110_AST);
 4459  46
                                                 match(RBRACK);
 4460  46
                                         }
 4461  
                                         else {
 4462  
                                                 break _loop357;
 4463  
                                         }
 4464  
                                         
 4465  
                                 } while (true);
 4466  
                                 }
 4467  
                                 {
 4468  198
                                 if ((LA(1)==DOT) && (LA(2)==LITERAL_class)) {
 4469  46
                                         AST tmp111_AST = null;
 4470  46
                                         tmp111_AST = astFactory.create(LT(1));
 4471  46
                                         astFactory.makeASTRoot(currentAST, tmp111_AST);
 4472  46
                                         match(DOT);
 4473  46
                                         AST tmp112_AST = null;
 4474  46
                                         tmp112_AST = astFactory.create(LT(1));
 4475  46
                                         astFactory.addASTChild(currentAST, tmp112_AST);
 4476  46
                                         match(LITERAL_class);
 4477  46
                                 }
 4478  152
                                 else if ((_tokenSet_17.member(LA(1))) && (_tokenSet_46.member(LA(2)))) {
 4479  
                                 }
 4480  
                                 else {
 4481  0
                                         throw new NoViableAltException(LT(1), getFilename());
 4482  
                                 }
 4483  
                                 
 4484  
                                 }
 4485  198
                                 primaryExpression_AST = (AST)currentAST.root;
 4486  
                         }
 4487  
                 else {
 4488  70
                         throw new NoViableAltException(LT(1), getFilename());
 4489  
                 }
 4490  
                 }
 4491  223037
                 returnAST = primaryExpression_AST;
 4492  223037
         }
 4493  
         
 4494  
 /** Declaration of a variable.  This can be a class/instance variable,
 4495  
  *   or a local variable in a method.
 4496  
     @param mods declaration mods.
 4497  
     @param t variable declaration type.
 4498  
     @throws RecognitionException if recognition problem occurs.
 4499  
     @throws TokenStreamException if problem occurs while generating a stream of tokens.
 4500  
  * It can also include possible initialization.
 4501  
  */
 4502  
         public final void variableDeclarator(
 4503  
                 AST mods, AST t
 4504  
         ) throws RecognitionException, TokenStreamException {
 4505  
                 
 4506  27364
                 returnAST = null;
 4507  27364
                 ASTPair currentAST = new ASTPair();
 4508  27364
                 AST variableDeclarator_AST = null;
 4509  27364
                 Token  id = null;
 4510  27364
                 AST id_AST = null;
 4511  27364
                 AST d_AST = null;
 4512  27364
                 AST v_AST = null;
 4513  
                 
 4514  27364
                 id = LT(1);
 4515  27364
                 id_AST = astFactory.create(id);
 4516  27364
                 match(IDENT);
 4517  24026
                 declaratorBrackets(t);
 4518  24026
                 d_AST = (AST)returnAST;
 4519  24026
                 varInitializer();
 4520  23726
                 v_AST = (AST)returnAST;
 4521  23726
                 if ( inputState.guessing==0 ) {
 4522  14482
                         variableDeclarator_AST = (AST)currentAST.root;
 4523  14482
                         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));
 4524  14482
                         currentAST.root = variableDeclarator_AST;
 4525  14482
                         currentAST.child = variableDeclarator_AST!=null &&variableDeclarator_AST.getFirstChild()!=null ?
 4526  14482
                                 variableDeclarator_AST.getFirstChild() : variableDeclarator_AST;
 4527  14482
                         currentAST.advanceChildToEnd();
 4528  
                 }
 4529  23726
                 returnAST = variableDeclarator_AST;
 4530  23726
         }
 4531  
         
 4532  
         public final void varInitializer() throws RecognitionException, TokenStreamException {
 4533  
                 
 4534  24026
                 returnAST = null;
 4535  24026
                 ASTPair currentAST = new ASTPair();
 4536  24026
                 AST varInitializer_AST = null;
 4537  
                 
 4538  
                 {
 4539  24026
                 switch ( LA(1)) {
 4540  
                 case ASSIGN:
 4541  
                 {
 4542  19173
                         AST tmp113_AST = null;
 4543  19173
                         tmp113_AST = astFactory.create(LT(1));
 4544  19173
                         astFactory.makeASTRoot(currentAST, tmp113_AST);
 4545  19173
                         match(ASSIGN);
 4546  19173
                         initializer();
 4547  19173
                         astFactory.addASTChild(currentAST, returnAST);
 4548  19173
                         break;
 4549  
                 }
 4550  
                 case FINAL:
 4551  
                 case ABSTRACT:
 4552  
                 case STRICTFP:
 4553  
                 case SEMI:
 4554  
                 case LITERAL_void:
 4555  
                 case LITERAL_boolean:
 4556  
                 case LITERAL_byte:
 4557  
                 case LITERAL_char:
 4558  
                 case LITERAL_short:
 4559  
                 case LITERAL_int:
 4560  
                 case LITERAL_float:
 4561  
                 case LITERAL_long:
 4562  
                 case LITERAL_double:
 4563  
                 case IDENT:
 4564  
                 case LITERAL_private:
 4565  
                 case LITERAL_public:
 4566  
                 case LITERAL_protected:
 4567  
                 case LITERAL_static:
 4568  
                 case LITERAL_transient:
 4569  
                 case LITERAL_native:
 4570  
                 case LITERAL_synchronized:
 4571  
                 case LITERAL_volatile:
 4572  
                 case LITERAL_class:
 4573  
                 case LITERAL_interface:
 4574  
                 case LCURLY:
 4575  
                 case RCURLY:
 4576  
                 case COMMA:
 4577  
                 case LITERAL_default:
 4578  
                 case LT:
 4579  
                 case ENUM:
 4580  
                 case AT:
 4581  
                 {
 4582  4553
                         break;
 4583  
                 }
 4584  
                 default:
 4585  
                 {
 4586  300
                         throw new NoViableAltException(LT(1), getFilename());
 4587  
                 }
 4588  
                 }
 4589  
                 }
 4590  23726
                 varInitializer_AST = (AST)currentAST.root;
 4591  23726
                 returnAST = varInitializer_AST;
 4592  23726
         }
 4593  
         
 4594  
         public final void initializer() throws RecognitionException, TokenStreamException {
 4595  
                 
 4596  22277
                 returnAST = null;
 4597  22277
                 ASTPair currentAST = new ASTPair();
 4598  22277
                 AST initializer_AST = null;
 4599  
                 
 4600  22277
                 switch ( LA(1)) {
 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 IDENT:
 4611  
                 case LPAREN:
 4612  
                 case LITERAL_this:
 4613  
                 case LITERAL_super:
 4614  
                 case PLUS:
 4615  
                 case MINUS:
 4616  
                 case INC:
 4617  
                 case DEC:
 4618  
                 case BNOT:
 4619  
                 case LNOT:
 4620  
                 case LITERAL_true:
 4621  
                 case LITERAL_false:
 4622  
                 case LITERAL_null:
 4623  
                 case LITERAL_new:
 4624  
                 case NUM_INT:
 4625  
                 case CHAR_LITERAL:
 4626  
                 case STRING_LITERAL:
 4627  
                 case NUM_FLOAT:
 4628  
                 case NUM_LONG:
 4629  
                 case NUM_DOUBLE:
 4630  
                 case AT:
 4631  
                 {
 4632  21665
                         expression();
 4633  21665
                         astFactory.addASTChild(currentAST, returnAST);
 4634  21665
                         initializer_AST = (AST)currentAST.root;
 4635  21665
                         break;
 4636  
                 }
 4637  
                 case LCURLY:
 4638  
                 {
 4639  612
                         arrayInitializer();
 4640  612
                         astFactory.addASTChild(currentAST, returnAST);
 4641  612
                         initializer_AST = (AST)currentAST.root;
 4642  612
                         break;
 4643  
                 }
 4644  
                 default:
 4645  
                 {
 4646  0
                         throw new NoViableAltException(LT(1), getFilename());
 4647  
                 }
 4648  
                 }
 4649  22277
                 returnAST = initializer_AST;
 4650  22277
         }
 4651  
         
 4652  
         public final void arrayInitializer() throws RecognitionException, TokenStreamException {
 4653  
                 
 4654  1110
                 returnAST = null;
 4655  1110
                 ASTPair currentAST = new ASTPair();
 4656  1110
                 AST arrayInitializer_AST = null;
 4657  1110
                 Token  lc = null;
 4658  1110
                 AST lc_AST = null;
 4659  
                 
 4660  1110
                 lc = LT(1);
 4661  1110
                 lc_AST = astFactory.create(lc);
 4662  1110
                 astFactory.makeASTRoot(currentAST, lc_AST);
 4663  1110
                 match(LCURLY);
 4664  1110
                 if ( inputState.guessing==0 ) {
 4665  790
                         lc_AST.setType(ARRAY_INIT);
 4666  
                 }
 4667  
                 {
 4668  1110
                 switch ( LA(1)) {
 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 IDENT:
 4679  
                 case LCURLY:
 4680  
                 case LPAREN:
 4681  
                 case LITERAL_this:
 4682  
                 case LITERAL_super:
 4683  
                 case PLUS:
 4684  
                 case MINUS:
 4685  
                 case INC:
 4686  
                 case DEC:
 4687  
                 case BNOT:
 4688  
                 case LNOT:
 4689  
                 case LITERAL_true:
 4690  
                 case LITERAL_false:
 4691  
                 case LITERAL_null:
 4692  
                 case LITERAL_new:
 4693  
                 case NUM_INT:
 4694  
                 case CHAR_LITERAL:
 4695  
                 case STRING_LITERAL:
 4696  
                 case NUM_FLOAT:
 4697  
                 case NUM_LONG:
 4698  
                 case NUM_DOUBLE:
 4699  
                 case AT:
 4700  
                 {
 4701  907
                         initializer();
 4702  907
                         astFactory.addASTChild(currentAST, returnAST);
 4703  
                         {
 4704  
                         _loop175:
 4705  
                         do {
 4706  3104
                                 if ((LA(1)==COMMA) && (_tokenSet_10.member(LA(2)))) {
 4707  2197
                                         AST tmp114_AST = null;
 4708  2197
                                         tmp114_AST = astFactory.create(LT(1));
 4709  2197
                                         astFactory.addASTChild(currentAST, tmp114_AST);
 4710  2197
                                         match(COMMA);
 4711  2197
                                         initializer();
 4712  2197
                                         astFactory.addASTChild(currentAST, returnAST);
 4713  2197
                                 }
 4714  
                                 else {
 4715  
                                         break _loop175;
 4716  
                                 }
 4717  
                                 
 4718  
                         } while (true);
 4719  
                         }
 4720  
                         break;
 4721  
                 }
 4722  
                 case RCURLY:
 4723  
                 case COMMA:
 4724  
                 {
 4725  203
                         break;
 4726  
                 }
 4727  
                 default:
 4728  
                 {
 4729  0
                         throw new NoViableAltException(LT(1), getFilename());
 4730  
                 }
 4731  
                 }
 4732  
                 }
 4733  
                 {
 4734  1110
                 switch ( LA(1)) {
 4735  
                 case COMMA:
 4736  
                 {
 4737  103
                         AST tmp115_AST = null;
 4738  103
                         tmp115_AST = astFactory.create(LT(1));
 4739  103
                         astFactory.addASTChild(currentAST, tmp115_AST);
 4740  103
                         match(COMMA);
 4741  103
                         break;
 4742  
                 }
 4743  
                 case RCURLY:
 4744  
                 {
 4745  1007
                         break;
 4746  
                 }
 4747  
                 default:
 4748  
                 {
 4749  0
                         throw new NoViableAltException(LT(1), getFilename());
 4750  
                 }
 4751  
                 }
 4752  
                 }
 4753  1110
                 AST tmp116_AST = null;
 4754  1110
                 tmp116_AST = astFactory.create(LT(1));
 4755  1110
                 astFactory.addASTChild(currentAST, tmp116_AST);
 4756  1110
                 match(RCURLY);
 4757  1110
                 arrayInitializer_AST = (AST)currentAST.root;
 4758  1110
                 returnAST = arrayInitializer_AST;
 4759  1110
         }
 4760  
         
 4761  
         public final void expression() throws RecognitionException, TokenStreamException {
 4762  
                 
 4763  66650
                 returnAST = null;
 4764  66650
                 ASTPair currentAST = new ASTPair();
 4765  66650
                 AST expression_AST = null;
 4766  
                 
 4767  66650
                 boolean synPredMatched270 = false;
 4768  66650
                 if (((LA(1)==IDENT||LA(1)==LPAREN) && (_tokenSet_15.member(LA(2))))) {
 4769  5004
                         int _m270 = mark();
 4770  5004
                         synPredMatched270 = true;
 4771  5004
                         inputState.guessing++;
 4772  
                         try {
 4773  
                                 {
 4774  5004
                                 lambdaExpression();
 4775  
                                 }
 4776  
                         }
 4777  4046
                         catch (RecognitionException pe) {
 4778  4046
                                 synPredMatched270 = false;
 4779  958
                         }
 4780  5004
                         rewind(_m270);
 4781  5004
 inputState.guessing--;
 4782  
                 }
 4783  66650
                 if ( synPredMatched270 ) {
 4784  958
                         lambdaExpression();
 4785  958
                         astFactory.addASTChild(currentAST, returnAST);
 4786  958
                         expression_AST = (AST)currentAST.root;
 4787  
                 }
 4788  65692
                 else if (((_tokenSet_12.member(LA(1))) && (_tokenSet_17.member(LA(2))))&&(LA(1)!=RPAREN)) {
 4789  65692
                         assignmentExpression();
 4790  65676
                         astFactory.addASTChild(currentAST, returnAST);
 4791  65676
                         if ( inputState.guessing==0 ) {
 4792  39816
                                 expression_AST = (AST)currentAST.root;
 4793  39816
                                 expression_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(EXPR,"EXPR")).add(expression_AST));
 4794  39816
                                 currentAST.root = expression_AST;
 4795  39816
                                 currentAST.child = expression_AST!=null &&expression_AST.getFirstChild()!=null ?
 4796  39816
                                         expression_AST.getFirstChild() : expression_AST;
 4797  39816
                                 currentAST.advanceChildToEnd();
 4798  
                         }
 4799  65676
                         expression_AST = (AST)currentAST.root;
 4800  
                 }
 4801  
                 else {
 4802  0
                         throw new NoViableAltException(LT(1), getFilename());
 4803  
                 }
 4804  
                 
 4805  66634
                 returnAST = expression_AST;
 4806  66634
         }
 4807  
         
 4808  
         public final void parameterDeclaration() throws RecognitionException, TokenStreamException {
 4809  
                 
 4810  14093
                 returnAST = null;
 4811  14093
                 ASTPair currentAST = new ASTPair();
 4812  14093
                 AST parameterDeclaration_AST = null;
 4813  14093
                 AST pm_AST = null;
 4814  14093
                 AST t_AST = null;
 4815  14093
                 AST id_AST = null;
 4816  14093
                 AST pd_AST = null;
 4817  
                 
 4818  14093
                 parameterModifier();
 4819  14093
                 pm_AST = (AST)returnAST;
 4820  
                 {
 4821  14093
                 if ((_tokenSet_9.member(LA(1))) && (_tokenSet_47.member(LA(2)))) {
 4822  11808
                         typeSpec(false);
 4823  11808
                         t_AST = (AST)returnAST;
 4824  
                 }
 4825  2285
                 else if ((LA(1)==IDENT||LA(1)==LITERAL_this) && (_tokenSet_48.member(LA(2)))) {
 4826  
                 }
 4827  
                 else {
 4828  185
                         throw new NoViableAltException(LT(1), getFilename());
 4829  
                 }
 4830  
                 
 4831  
                 }
 4832  13908
                 parameterIdent();
 4833  13810
                 id_AST = (AST)returnAST;
 4834  13810
                 declaratorBrackets(t_AST);
 4835  13810
                 pd_AST = (AST)returnAST;
 4836  13810
                 if ( inputState.guessing==0 ) {
 4837  5740
                         parameterDeclaration_AST = (AST)currentAST.root;
 4838  5740
                         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));
 4839  5740
                         currentAST.root = parameterDeclaration_AST;
 4840  5740
                         currentAST.child = parameterDeclaration_AST!=null &&parameterDeclaration_AST.getFirstChild()!=null ?
 4841  5740
                                 parameterDeclaration_AST.getFirstChild() : parameterDeclaration_AST;
 4842  5740
                         currentAST.advanceChildToEnd();
 4843  
                 }
 4844  13810
                 returnAST = parameterDeclaration_AST;
 4845  13810
         }
 4846  
         
 4847  
         public final void variableLengthParameterDeclaration() throws RecognitionException, TokenStreamException {
 4848  
                 
 4849  182
                 returnAST = null;
 4850  182
                 ASTPair currentAST = new ASTPair();
 4851  182
                 AST variableLengthParameterDeclaration_AST = null;
 4852  182
                 AST pm_AST = null;
 4853  182
                 AST t_AST = null;
 4854  182
                 Token  td = null;
 4855  182
                 AST td_AST = null;
 4856  182
                 AST pd_AST = null;
 4857  
                 
 4858  182
                 parameterModifier();
 4859  182
                 pm_AST = (AST)returnAST;
 4860  182
                 typeSpec(false);
 4861  182
                 t_AST = (AST)returnAST;
 4862  182
                 td = LT(1);
 4863  182
                 td_AST = astFactory.create(td);
 4864  182
                 match(ELLIPSIS);
 4865  92
                 AST tmp117_AST = null;
 4866  92
                 tmp117_AST = astFactory.create(LT(1));
 4867  92
                 match(IDENT);
 4868  92
                 declaratorBrackets(t_AST);
 4869  92
                 pd_AST = (AST)returnAST;
 4870  92
                 if ( inputState.guessing==0 ) {
 4871  92
                         variableLengthParameterDeclaration_AST = (AST)currentAST.root;
 4872  92
                         variableLengthParameterDeclaration_AST = (AST)astFactory.make( (new ASTArray(5)).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(td_AST).add(tmp117_AST));
 4873  92
                         currentAST.root = variableLengthParameterDeclaration_AST;
 4874  92
                         currentAST.child = variableLengthParameterDeclaration_AST!=null &&variableLengthParameterDeclaration_AST.getFirstChild()!=null ?
 4875  92
                                 variableLengthParameterDeclaration_AST.getFirstChild() : variableLengthParameterDeclaration_AST;
 4876  92
                         currentAST.advanceChildToEnd();
 4877  
                 }
 4878  92
                 returnAST = variableLengthParameterDeclaration_AST;
 4879  92
         }
 4880  
         
 4881  
         public final void parameterModifier() throws RecognitionException, TokenStreamException {
 4882  
                 
 4883  15358
                 returnAST = null;
 4884  15358
                 ASTPair currentAST = new ASTPair();
 4885  15358
                 AST parameterModifier_AST = null;
 4886  15358
                 Token  f = null;
 4887  15358
                 AST f_AST = null;
 4888  
                 
 4889  
                 {
 4890  
                 _loop197:
 4891  
                 do {
 4892  15680
                         if ((LA(1)==AT) && (LA(2)==IDENT)) {
 4893  322
                                 annotation();
 4894  322
                                 astFactory.addASTChild(currentAST, returnAST);
 4895  
                         }
 4896  
                         else {
 4897  
                                 break _loop197;
 4898  
                         }
 4899  
                         
 4900  
                 } while (true);
 4901  
                 }
 4902  
                 {
 4903  15358
                 switch ( LA(1)) {
 4904  
                 case FINAL:
 4905  
                 {
 4906  487
                         f = LT(1);
 4907  487
                         f_AST = astFactory.create(f);
 4908  487
                         astFactory.addASTChild(currentAST, f_AST);
 4909  487
                         match(FINAL);
 4910  487
                         break;
 4911  
                 }
 4912  
                 case LITERAL_void:
 4913  
                 case LITERAL_boolean:
 4914  
                 case LITERAL_byte:
 4915  
                 case LITERAL_char:
 4916  
                 case LITERAL_short:
 4917  
                 case LITERAL_int:
 4918  
                 case LITERAL_float:
 4919  
                 case LITERAL_long:
 4920  
                 case LITERAL_double:
 4921  
                 case IDENT:
 4922  
                 case LITERAL_this:
 4923  
                 case AT:
 4924  
                 {
 4925  14871
                         break;
 4926  
                 }
 4927  
                 default:
 4928  
                 {
 4929  0
                         throw new NoViableAltException(LT(1), getFilename());
 4930  
                 }
 4931  
                 }
 4932  
                 }
 4933  
                 {
 4934  
                 _loop200:
 4935  
                 do {
 4936  15376
                         if ((LA(1)==AT) && (LA(2)==IDENT)) {
 4937  18
                                 annotation();
 4938  18
                                 astFactory.addASTChild(currentAST, returnAST);
 4939  
                         }
 4940  
                         else {
 4941  
                                 break _loop200;
 4942  
                         }
 4943  
                         
 4944  
                 } while (true);
 4945  
                 }
 4946  15358
                 if ( inputState.guessing==0 ) {
 4947  6915
                         parameterModifier_AST = (AST)currentAST.root;
 4948  6915
                         parameterModifier_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(MODIFIERS,"MODIFIERS")).add(parameterModifier_AST));
 4949  6915
                         currentAST.root = parameterModifier_AST;
 4950  6915
                         currentAST.child = parameterModifier_AST!=null &&parameterModifier_AST.getFirstChild()!=null ?
 4951  351
                                 parameterModifier_AST.getFirstChild() : parameterModifier_AST;
 4952  6915
                         currentAST.advanceChildToEnd();
 4953  
                 }
 4954  15358
                 parameterModifier_AST = (AST)currentAST.root;
 4955  15358
                 returnAST = parameterModifier_AST;
 4956  15358
         }
 4957  
         
 4958  
         public final void parameterIdent() throws RecognitionException, TokenStreamException {
 4959  
                 
 4960  13908
                 returnAST = null;
 4961  13908
                 ASTPair currentAST = new ASTPair();
 4962  13908
                 AST parameterIdent_AST = null;
 4963  
                 
 4964  13908
                 switch ( LA(1)) {
 4965  
                 case LITERAL_this:
 4966  
                 {
 4967  102
                         AST tmp118_AST = null;
 4968  102
                         tmp118_AST = astFactory.create(LT(1));
 4969  102
                         astFactory.addASTChild(currentAST, tmp118_AST);
 4970  102
                         match(LITERAL_this);
 4971  102
                         parameterIdent_AST = (AST)currentAST.root;
 4972  102
                         break;
 4973  
                 }
 4974  
                 case IDENT:
 4975  
                 {
 4976  
                         {
 4977  13708
                         AST tmp119_AST = null;
 4978  13708
                         tmp119_AST = astFactory.create(LT(1));
 4979  13708
                         astFactory.addASTChild(currentAST, tmp119_AST);
 4980  13708
                         match(IDENT);
 4981  
                         {
 4982  13708
                         switch ( LA(1)) {
 4983  
                         case DOT:
 4984  
                         {
 4985  34
                                 AST tmp120_AST = null;
 4986  34
                                 tmp120_AST = astFactory.create(LT(1));
 4987  34
                                 astFactory.makeASTRoot(currentAST, tmp120_AST);
 4988  34
                                 match(DOT);
 4989  34
                                 AST tmp121_AST = null;
 4990  34
                                 tmp121_AST = astFactory.create(LT(1));
 4991  34
                                 astFactory.addASTChild(currentAST, tmp121_AST);
 4992  34
                                 match(LITERAL_this);
 4993  34
                                 break;
 4994  
                         }
 4995  
                         case LBRACK:
 4996  
                         case COMMA:
 4997  
                         case RPAREN:
 4998  
                         {
 4999  13674
                                 break;
 5000  
                         }
 5001  
                         default:
 5002 &nb