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