Clover coverage report - JBind Project
Coverage timestamp: Fr Mai 28 2004 11:17:36 CEST
file stats: LOC: 6.955   Methods: 520
NCLOC: 6.384   Classes: 2
This license of Clover is provided to support the development of JBind only. Please visit http://www.thecortex.net/clover to obtain a licensed version of Clover.
 
 Source file Conditionals Statements Methods TOTAL
JavaParser.java 12% 21,5% 44,6% 19,4%
 1   
 /* Generated By:JavaCC: Do not edit this line. JavaParser.java */
 2   
 package org.jbind.javaParser;
 3   
 
 4   
 public class JavaParser implements JavaParserConstants {
 5   
 // modified main Andrea Gini 24/02/2002
 6   
 // modified main. DW, 7/99
 7  0
     public static void main (String [] args) {
 8  0
         JavaParser parser;
 9  0
         String filename = null;
 10  0
         long initTime = 0;
 11  0
         long parseTime = 0;
 12  0
         long startTime = 0;
 13  0
         long stopTime = 0;
 14  0
         if (args.length == 0)
 15   
         {
 16  0
             System.out.println("Java Parser Version 1.1 (for Java1.4 code):  Reading from standard input . . .");
 17  0
             parser = new JavaParser(System.in);
 18  0
         } else if (args.length == 1)
 19   
         {
 20  0
             filename = args[0];
 21  0
             System.out.println("Java Parser Version 1.1 (for Java1.4 code):  Reading from file " + filename + " . . .");
 22  0
             try
 23   
             {
 24  0
                 startTime = System.currentTimeMillis();
 25  0
                 parser = new JavaParser(new java.io.FileInputStream(filename));
 26  0
                 stopTime = System.currentTimeMillis();
 27  0
                 initTime = stopTime - startTime;
 28   
             } catch (java.io.FileNotFoundException e)
 29   
             {
 30  0
                 System.out.println("Java Parser Version 1.1 (for Java1.4 code):  File " + filename + " not found.");
 31  0
                 return;
 32   
             }
 33   
         } else
 34   
         {
 35  0
             System.out.println("Java Parser Version 1.1 (for Java1.4 code):  Usage is one of:");
 36  0
             System.out.println("         java JavaParser < inputfile");
 37  0
             System.out.println("OR");
 38  0
             System.out.println("         java JavaParser inputfile");
 39  0
             return;
 40   
         }
 41  0
         try
 42   
         {
 43  0
             startTime = System.currentTimeMillis();
 44  0
             parser.CompilationUnit();
 45  0
             stopTime = System.currentTimeMillis();
 46  0
             parseTime = stopTime - startTime;
 47  0
             System.out.println("Java Parser Version 1.1 (for Java1.4 code): ");
 48  0
             System.out.println("   Java program parsed " + filename + " successfully in " + (initTime + parseTime) + " ms.");
 49  0
             System.out.println("      parser initialization time was " + initTime + " ms.");
 50  0
             System.out.println("      parser parse time was " + parseTime + " ms.");
 51   
         } catch (ParseException e)
 52   
         {
 53  0
             System.out.println(e.getMessage());
 54  0
             System.out.println("Java Parser Version 1.1 (for Java1.4 code):  Encountered errors during parse.");
 55   
         }
 56   
     }
 57   
 
 58   
 /*****************************************
 59   
  * THE JAVA LANGUAGE GRAMMAR STARTS HERE *
 60   
  *****************************************/
 61   
 
 62   
 /*
 63   
  * Program structuring syntax follows.
 64   
  */
 65  8
   final public ASTCompilationUnit CompilationUnit() throws ParseException {
 66  8
   ASTCompilationUnit jjtThis = new ASTCompilationUnit();
 67  8
   ASTTypeDeclaration td = null;
 68  8
     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
 69   
     case PACKAGE:
 70  8
       PackageDeclaration();
 71  8
       break;
 72   
     default:
 73  0
       jj_la1[0] = jj_gen;
 74   
       ;
 75   
     }
 76  8
     label_1:
 77   
     while (true) {
 78  8
       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
 79   
       case IMPORT:
 80   
         ;
 81  0
         break;
 82   
       default:
 83  8
         jj_la1[1] = jj_gen;
 84  8
         break label_1;
 85   
       }
 86  0
       ImportDeclaration();
 87   
     }
 88  8
     label_2:
 89   
     while (true) {
 90  16
       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
 91   
       case ABSTRACT:
 92   
       case CLASS:
 93   
       case FINAL:
 94   
       case INTERFACE:
 95   
       case PUBLIC:
 96   
       case STRICTFP:
 97   
       case SEMICOLON:
 98   
         ;
 99  8
         break;
 100   
       default:
 101  8
         jj_la1[2] = jj_gen;
 102  8
         break label_2;
 103   
       }
 104  8
       td = TypeDeclaration();
 105  8
                              jjtThis.addTypeDeclaration(td);
 106   
     }
 107  8
     jj_consume_token(0);
 108  8
     {if (true) return jjtThis;}
 109  0
     throw new Error("Missing return statement in function");
 110   
   }
 111   
 
 112  8
   final public void PackageDeclaration() throws ParseException {
 113  8
     jj_consume_token(PACKAGE);
 114  8
     Name();
 115  8
     jj_consume_token(SEMICOLON);
 116   
   }
 117   
 
 118  0
   final public void ImportDeclaration() throws ParseException {
 119  0
     jj_consume_token(IMPORT);
 120  0
     Name();
 121  0
     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
 122   
     case DOT:
 123  0
       jj_consume_token(DOT);
 124  0
       jj_consume_token(STAR);
 125  0
       break;
 126   
     default:
 127  0
       jj_la1[3] = jj_gen;
 128   
       ;
 129   
     }
 130  0
     jj_consume_token(SEMICOLON);
 131   
   }
 132   
 
 133  8
   final public ASTTypeDeclaration TypeDeclaration() throws ParseException {
 134  8
   ASTTypeDeclaration jjtThis = new ASTTypeDeclaration();
 135  8
   ASTUnmodifiedClassDeclaration cd;
 136  8
   ASTUnmodifiedInterfaceDeclaration id;
 137  8
     if (jj_2_1(2147483647)) {
 138  4
       cd = ClassDeclaration();
 139  4
                             jjtThis.setClassDeclaration(cd);
 140   
     } else {
 141  4
       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
 142   
       case ABSTRACT:
 143   
       case INTERFACE:
 144   
       case PUBLIC:
 145   
       case STRICTFP:
 146  4
         id = InterfaceDeclaration();
 147  4
                                 jjtThis.setInterfaceDeclaration(id);
 148  4
         break;
 149   
       case SEMICOLON:
 150  0
         jj_consume_token(SEMICOLON);
 151  0
         break;
 152   
       default:
 153  0
         jj_la1[4] = jj_gen;
 154  0
         jj_consume_token(-1);
 155  0
         throw new ParseException();
 156   
       }
 157   
     }
 158  8
     {if (true) return jjtThis;}
 159  0
     throw new Error("Missing return statement in function");
 160   
   }
 161   
 
 162   
 /*
 163   
  * Declaration syntax follows.
 164   
  */
 165  4
   final public ASTUnmodifiedClassDeclaration ClassDeclaration() throws ParseException {
 166  4
   ASTUnmodifiedClassDeclaration res;
 167  4
     label_3:
 168   
     while (true) {
 169  12
       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
 170   
       case ABSTRACT:
 171   
       case FINAL:
 172   
       case PUBLIC:
 173   
       case STRICTFP:
 174   
         ;
 175  8
         break;
 176   
       default:
 177  4
         jj_la1[5] = jj_gen;
 178  4
         break label_3;
 179   
       }
 180  8
       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
 181   
       case ABSTRACT:
 182  4
         jj_consume_token(ABSTRACT);
 183  4
         break;
 184   
       case FINAL:
 185  0
         jj_consume_token(FINAL);
 186  0
         break;
 187   
       case PUBLIC:
 188  4
         jj_consume_token(PUBLIC);
 189  4
         break;
 190   
       case STRICTFP:
 191  0
         jj_consume_token(STRICTFP);
 192  0
         break;
 193   
       default:
 194  0
         jj_la1[6] = jj_gen;
 195  0
         jj_consume_token(-1);
 196  0
         throw new ParseException();
 197   
       }
 198   
     }
 199  4
     res = UnmodifiedClassDeclaration();
 200  4
     {if (true) return res;}
 201  0
     throw new Error("Missing return statement in function");
 202   
   }
 203   
 
 204  4
   final public ASTUnmodifiedClassDeclaration UnmodifiedClassDeclaration() throws ParseException {
 205  4
   ASTUnmodifiedClassDeclaration jjtThis = new ASTUnmodifiedClassDeclaration();
 206  4
   ASTName ext = null;
 207  4
   ASTNameList imp = null;
 208  4
     jj_consume_token(CLASS);
 209  4
     jj_consume_token(IDENTIFIER);
 210  4
     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
 211   
     case EXTENDS:
 212  4
       jj_consume_token(EXTENDS);
 213  4
       ext = Name();
 214  4
                                                   jjtThis.setExtends(ext);
 215  4
       break;
 216   
     default:
 217  0
       jj_la1[7] = jj_gen;
 218   
       ;
 219   
     }
 220  4
     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
 221   
     case IMPLEMENTS:
 222  4
       jj_consume_token(IMPLEMENTS);
 223  4
       imp = NameList();
 224  4
                                                                                                                  jjtThis.setImplements(imp);
 225  4
       break;
 226   
     default:
 227  0
       jj_la1[8] = jj_gen;
 228   
       ;
 229   
     }
 230  4
     ClassBody();
 231  4
     {if (true) return jjtThis;}
 232  0
     throw new Error("Missing return statement in function");
 233   
   }
 234   
 
 235  4
   final public void ClassBody() throws ParseException {
 236  4
     jj_consume_token(LBRACE);
 237  4
     label_4:
 238   
     while (true) {
 239  13
       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
 240   
       case ABSTRACT:
 241   
       case BOOLEAN:
 242   
       case BYTE:
 243   
       case CHAR:
 244   
       case CLASS:
 245   
       case DOUBLE:
 246   
       case FINAL:
 247   
       case FLOAT:
 248   
       case INT:
 249   
       case INTERFACE:
 250   
       case LONG:
 251   
       case NATIVE:
 252   
       case PRIVATE:
 253   
       case PROTECTED:
 254   
       case PUBLIC:
 255   
       case SHORT:
 256   
       case STATIC:
 257   
       case SYNCHRONIZED:
 258   
       case TRANSIENT:
 259   
       case VOID:
 260   
       case VOLATILE:
 261   
       case STRICTFP:
 262   
       case IDENTIFIER:
 263   
       case LBRACE:
 264   
       case SEMICOLON:
 265   
         ;
 266  9
         break;
 267   
       default:
 268  4
         jj_la1[9] = jj_gen;
 269  4
         break label_4;
 270   
       }
 271  9
       ClassBodyDeclaration();
 272   
     }
 273  4
     jj_consume_token(RBRACE);
 274   
   }
 275   
 
 276  0
   final public void NestedClassDeclaration() throws ParseException {
 277  0
     label_5:
 278   
     while (true) {
 279  0
       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
 280   
       case ABSTRACT:
 281   
       case FINAL:
 282   
       case PRIVATE:
 283   
       case PROTECTED:
 284   
       case PUBLIC:
 285   
       case STATIC:
 286   
       case STRICTFP:
 287   
         ;
 288  0
         break;
 289   
       default:
 290  0
         jj_la1[10] = jj_gen;
 291  0
         break label_5;
 292   
       }
 293  0
       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
 294   
       case STATIC:
 295  0
         jj_consume_token(STATIC);
 296  0
         break;
 297   
       case ABSTRACT:
 298  0
         jj_consume_token(ABSTRACT);
 299  0
         break;
 300   
       case FINAL:
 301  0
         jj_consume_token(FINAL);
 302  0
         break;
 303   
       case PUBLIC:
 304  0
         jj_consume_token(PUBLIC);
 305  0
         break;
 306   
       case PROTECTED:
 307  0
         jj_consume_token(PROTECTED);
 308  0
         break;
 309   
       case PRIVATE:
 310  0
         jj_consume_token(PRIVATE);
 311  0
         break;
 312   
       case STRICTFP:
 313  0
         jj_consume_token(STRICTFP);
 314  0
         break;
 315   
       default:
 316  0
         jj_la1[11] = jj_gen;
 317  0
         jj_consume_token(-1);
 318  0
         throw new ParseException();
 319   
       }
 320   
     }
 321  0
     UnmodifiedClassDeclaration();
 322   
   }
 323   
 
 324   
 /* Modified by Andrea Gini 2 
 325   
  * According rules ClassBody and ClassBodyDeclaration
 326   
  * in the Java Language Specification,
 327   
  * semi-colons can be duplicated.
 328   
  * Source : http://java.sun.com/docs/books/jls/second_edition/html/syntax.doc.html
 329   
  */
 330  9
   final public void ClassBodyDeclaration() throws ParseException {
 331  9
     if (jj_2_2(2)) {
 332  0
       Initializer();
 333  9
     } else if (jj_2_3(2147483647)) {
 334  0
       NestedClassDeclaration();
 335  9
     } else if (jj_2_4(2147483647)) {
 336  0
       NestedInterfaceDeclaration();
 337  9
     } else if (jj_2_5(2147483647)) {
 338  0
       ConstructorDeclaration();
 339  9
     } else if (jj_2_6(2147483647)) {
 340  6
       MethodDeclaration();
 341   
     } else {
 342  3
       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
 343   
       case BOOLEAN:
 344   
       case BYTE:
 345   
       case CHAR:
 346   
       case DOUBLE:
 347   
       case FINAL:
 348   
       case FLOAT:
 349   
       case INT:
 350   
       case LONG:
 351   
       case PRIVATE:
 352   
       case PROTECTED:
 353   
       case PUBLIC:
 354   
       case SHORT:
 355   
       case STATIC:
 356   
       case TRANSIENT:
 357   
       case VOLATILE:
 358   
       case IDENTIFIER:
 359  3
         FieldDeclaration();
 360  3
         break;
 361   
       case SEMICOLON:
 362  0
         jj_consume_token(SEMICOLON);
 363  0
         break;
 364   
       default:
 365  0
         jj_la1[12] = jj_gen;
 366  0
         jj_consume_token(-1);
 367  0
         throw new ParseException();
 368   
       }
 369   
     }
 370   
   }
 371   
 
 372   
 // This production is to determine lookahead only.
 373  0
   final public void MethodDeclarationLookahead() throws ParseException {
 374  0
     label_6:
 375   
     while (true) {
 376  0
       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
 377   
       case ABSTRACT:
 378   
       case FINAL:
 379   
       case NATIVE:
 380   
       case PRIVATE:
 381   
       case PROTECTED:
 382   
       case PUBLIC:
 383   
       case STATIC:
 384   
       case SYNCHRONIZED:
 385   
       case STRICTFP:
 386   
         ;
 387  0
         break;
 388   
       default:
 389  0
         jj_la1[13] = jj_gen;
 390  0
         break label_6;
 391   
       }
 392  0
       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
 393   
       case PUBLIC:
 394  0
         jj_consume_token(PUBLIC);
 395  0
         break;
 396   
       case PROTECTED:
 397  0
         jj_consume_token(PROTECTED);
 398  0
         break;
 399   
       case PRIVATE:
 400  0
         jj_consume_token(PRIVATE);
 401  0
         break;
 402   
       case STATIC:
 403  0
         jj_consume_token(STATIC);
 404  0
         break;
 405   
       case ABSTRACT:
 406  0
         jj_consume_token(ABSTRACT);
 407  0
         break;
 408   
       case FINAL:
 409  0
         jj_consume_token(FINAL);
 410  0
         break;
 411   
       case NATIVE:
 412  0
         jj_consume_token(NATIVE);
 413  0
         break;
 414   
       case SYNCHRONIZED:
 415  0
         jj_consume_token(SYNCHRONIZED);
 416  0
         break;
 417   
       case STRICTFP:
 418  0
         jj_consume_token(STRICTFP);
 419  0
         break;
 420   
       default:
 421  0
         jj_la1[14] = jj_gen;
 422  0
         jj_consume_token(-1);
 423  0
         throw new ParseException();
 424   
       }
 425   
     }
 426  0
     ResultType();
 427  0
     jj_consume_token(IDENTIFIER);
 428  0
     jj_consume_token(LPAREN);
 429   
   }
 430   
 
 431  4
   final public ASTUnmodifiedInterfaceDeclaration InterfaceDeclaration() throws ParseException {
 432  4
   ASTUnmodifiedInterfaceDeclaration res;
 433  4
     label_7:
 434   
     while (true) {
 435  8
       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
 436   
       case ABSTRACT:
 437   
       case PUBLIC:
 438   
       case STRICTFP:
 439   
         ;
 440  4
         break;
 441   
       default:
 442  4
         jj_la1[15] = jj_gen;
 443  4
         break label_7;
 444   
       }
 445  4
       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
 446   
       case ABSTRACT:
 447  0
         jj_consume_token(ABSTRACT);
 448  0
         break;
 449   
       case PUBLIC:
 450  4
         jj_consume_token(PUBLIC);
 451  4
         break;
 452   
       case STRICTFP:
 453  0
         jj_consume_token(STRICTFP);
 454  0
         break;
 455   
       default:
 456  0
         jj_la1[16] = jj_gen;
 457  0
         jj_consume_token(-1);
 458  0
         throw new ParseException();
 459   
       }
 460   
     }
 461  4
     res = UnmodifiedInterfaceDeclaration();
 462  4
     {if (true) return res;}
 463  0
     throw new Error("Missing return statement in function");
 464   
   }
 465   
 
 466  0
   final public void NestedInterfaceDeclaration() throws ParseException {
 467  0
     label_8:
 468   
     while (true) {
 469  0
       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
 470   
       case ABSTRACT:
 471   
       case FINAL:
 472   
       case PRIVATE:
 473   
       case PROTECTED:
 474   
       case PUBLIC:
 475   
       case STATIC:
 476   
       case STRICTFP:
 477   
         ;
 478  0
         break;
 479   
       default:
 480  0
         jj_la1[17] = jj_gen;
 481  0
         break label_8;
 482   
       }
 483  0
       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
 484   
       case STATIC:
 485  0
         jj_consume_token(STATIC);
 486  0
         break;
 487   
       case ABSTRACT:
 488  0
         jj_consume_token(ABSTRACT);
 489  0
         break;
 490   
       case FINAL:
 491  0
         jj_consume_token(FINAL);
 492  0
         break;
 493   
       case PUBLIC:
 494  0
         jj_consume_token(PUBLIC);
 495  0
         break;
 496   
       case PROTECTED:
 497  0
         jj_consume_token(PROTECTED);
 498  0
         break;
 499   
       case PRIVATE:
 500  0
         jj_consume_token(PRIVATE);
 501  0
         break;
 502   
       case STRICTFP:
 503  0
         jj_consume_token(STRICTFP);
 504  0
         break;
 505   
       default:
 506  0
         jj_la1[18] = jj_gen;
 507  0
         jj_consume_token(-1);
 508  0
         throw new ParseException();
 509   
       }
 510   
     }
 511  0
     UnmodifiedInterfaceDeclaration();
 512   
   }
 513   
 
 514  4
   final public ASTUnmodifiedInterfaceDeclaration UnmodifiedInterfaceDeclaration() throws ParseException {
 515  4
   ASTUnmodifiedInterfaceDeclaration jjtThis = new ASTUnmodifiedInterfaceDeclaration();
 516  4
   ASTNameList ext;
 517  4
     jj_consume_token(INTERFACE);
 518  4
     jj_consume_token(IDENTIFIER);
 519  4
     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
 520   
     case EXTENDS:
 521  4
       jj_consume_token(EXTENDS);
 522  4
       ext = NameList();
 523  4
                                                           jjtThis.setExtends(ext);
 524  4
       break;
 525   
     default:
 526  0
       jj_la1[19] = jj_gen;
 527   
       ;
 528   
     }
 529  4
     jj_consume_token(LBRACE);
 530  4
     label_9:
 531   
     while (true) {
 532  7
       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
 533   
       case ABSTRACT:
 534   
       case BOOLEAN:
 535   
       case BYTE:
 536   
       case CHAR:
 537   
       case CLASS:
 538   
       case DOUBLE:
 539   
       case FINAL:
 540   
       case FLOAT:
 541   
       case INT:
 542   
       case INTERFACE:
 543   
       case LONG:
 544   
       case NATIVE:
 545   
       case PRIVATE:
 546   
       case PROTECTED:
 547   
       case PUBLIC:
 548   
       case SHORT:
 549   
       case STATIC:
 550   
       case SYNCHRONIZED:
 551   
       case TRANSIENT:
 552   
       case VOID:
 553   
       case VOLATILE:
 554   
       case STRICTFP:
 555   
       case IDENTIFIER:
 556   
       case SEMICOLON:
 557   
         ;
 558  3
         break;
 559   
       default:
 560  4
         jj_la1[20] = jj_gen;
 561  4
         break label_9;
 562   
       }
 563  3
       InterfaceMemberDeclaration();
 564   
     }
 565  4
     jj_consume_token(RBRACE);
 566  4
     {if (true) return jjtThis;}
 567  0
     throw new Error("Missing return statement in function");
 568   
   }
 569   
 
 570   
 /* Modified by Andrea Gini 2 
 571   
  * According to rules InterfaceBody and InterfaceBodyDeclaration
 572   
  * in the Java Language Specification,
 573   
  * semi-colons can be duplicated.
 574   
  * Source : http://java.sun.com/docs/books/jls/second_edition/html/syntax.doc.html
 575   
  */
 576  3
   final public void InterfaceMemberDeclaration() throws ParseException {
 577  3
     if (jj_2_7(2147483647)) {
 578  0
       NestedClassDeclaration();
 579  3
     } else if (jj_2_8(2147483647)) {
 580  0
       NestedInterfaceDeclaration();
 581  3
     } else if (jj_2_9(2147483647)) {
 582  3
       MethodDeclaration();
 583   
     } else {
 584  0
       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
 585   
       case BOOLEAN:
 586   
       case BYTE:
 587   
       case CHAR:
 588   
       case DOUBLE:
 589   
       case FINAL:
 590   
       case FLOAT:
 591   
       case INT:
 592   
       case LONG:
 593   
       case PRIVATE:
 594   
       case PROTECTED:
 595   
       case PUBLIC:
 596   
       case SHORT:
 597   
       case STATIC:
 598   
       case TRANSIENT:
 599   
       case VOLATILE:
 600   
       case IDENTIFIER:
 601  0
         FieldDeclaration();
 602  0
         break;
 603   
       case SEMICOLON:
 604  0
         jj_consume_token(SEMICOLON);
 605  0
         break;
 606   
       default:
 607  0
         jj_la1[21] = jj_gen;
 608  0
         jj_consume_token(-1);
 609  0
         throw new ParseException();
 610   
       }
 611   
     }
 612   
   }
 613   
 
 614  3
   final public void FieldDeclaration() throws ParseException {
 615  3
     label_10:
 616   
     while (true) {
 617  6
       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
 618   
       case FINAL:
 619   
       case PRIVATE:
 620   
       case PROTECTED:
 621   
       case PUBLIC:
 622   
       case STATIC:
 623   
       case TRANSIENT:
 624   
       case VOLATILE:
 625   
         ;
 626  3
         break;
 627   
       default:
 628  3
         jj_la1[22] = jj_gen;
 629  3
         break label_10;
 630   
       }
 631  3
       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
 632   
       case PUBLIC:
 633  0
         jj_consume_token(PUBLIC);
 634  0
         break;
 635   
       case PROTECTED:
 636  0
         jj_consume_token(PROTECTED);
 637  0
         break;
 638   
       case PRIVATE:
 639  3
         jj_consume_token(PRIVATE);
 640  3
         break;
 641   
       case STATIC:
 642  0
         jj_consume_token(STATIC);
 643  0
         break;
 644   
       case FINAL:
 645  0
         jj_consume_token(FINAL);
 646  0
         break;
 647   
       case TRANSIENT:
 648  0
         jj_consume_token(TRANSIENT);
 649  0
         break;
 650   
       case VOLATILE:
 651  0
         jj_consume_token(VOLATILE);
 652  0
         break;
 653   
       default:
 654  0
         jj_la1[23] = jj_gen;
 655  0
         jj_consume_token(-1);
 656  0
         throw new ParseException();
 657   
       }
 658   
     }
 659  3
     Type();
 660  3
     VariableDeclarator();
 661  3
     label_11:
 662   
     while (true) {
 663  3
       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
 664   
       case COMMA:
 665   
         ;
 666  0
         break;
 667   
       default:
 668  3
         jj_la1[24] = jj_gen;
 669  3
         break label_11;
 670   
       }
 671  0
       jj_consume_token(COMMA);
 672  0
       VariableDeclarator();
 673   
     }
 674  3
     jj_consume_token(SEMICOLON);
 675   
   }
 676   
 
 677  3
   final public void VariableDeclarator() throws ParseException {
 678  3
     VariableDeclaratorId();
 679  3
     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
 680   
     case ASSIGN:
 681  3
       jj_consume_token(ASSIGN);
 682  3
       VariableInitializer();
 683  3
       break;
 684   
     default:
 685  0
       jj_la1[25] = jj_gen;
 686   
       ;
 687   
     }
 688   
   }
 689   
 
 690  5
   final public void VariableDeclaratorId() throws ParseException {
 691  5
     jj_consume_token(IDENTIFIER);
 692  5
     label_12:
 693   
     while (true) {
 694  5
       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
 695   
       case LBRACKET:
 696   
         ;
 697  0
         break;
 698   
       default:
 699  5
         jj_la1[26] = jj_gen;
 700  5
         break label_12;
 701   
       }
 702  0
       jj_consume_token(LBRACKET);
 703  0
       jj_consume_token(RBRACKET);
 704   
     }
 705   
   }
 706   
 
 707  3
   final public void VariableInitializer() throws ParseException {
 708  3
     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
 709   
     case LBRACE:
 710  0
       ArrayInitializer();
 711  0
       break;
 712   
     case BOOLEAN:
 713   
     case BYTE:
 714   
     case CHAR:
 715   
     case DOUBLE:
 716   
     case FALSE:
 717   
     case FLOAT:
 718   
     case INT:
 719   
     case LONG:
 720   
     case NEW:
 721   
     case NULL:
 722   
     case SHORT:
 723   
     case SUPER:
 724   
     case THIS:
 725   
     case TRUE:
 726   
     case VOID:
 727   
     case INTEGER_LITERAL:
 728   
     case FLOATING_POINT_LITERAL:
 729   
     case CHARACTER_LITERAL:
 730   
     case STRING_LITERAL:
 731   
     case IDENTIFIER:
 732   
     case LPAREN:
 733   
     case BANG:
 734   
     case TILDE:
 735   
     case INCR:
 736   
     case DECR:
 737   
     case PLUS:
 738   
     case MINUS:
 739  3
       Expression();
 740  3
       break;
 741   
     default:
 742  0
       jj_la1[27] = jj_gen;
 743  0
       jj_consume_token(-1);
 744  0
       throw new ParseException();
 745   
     }
 746   
   }
 747   
 
 748  0
   final public void ArrayInitializer() throws ParseException {
 749  0
     jj_consume_token(LBRACE);
 750  0
     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
 751   
     case BOOLEAN:
 752   
     case BYTE:
 753   
     case CHAR:
 754   
     case DOUBLE:
 755   
     case FALSE:
 756   
     case FLOAT:
 757   
     case INT:
 758   
     case LONG:
 759   
     case NEW:
 760   
     case NULL:
 761   
     case SHORT:
 762   
     case SUPER:
 763   
     case THIS:
 764   
     case TRUE:
 765   
     case VOID:
 766   
     case INTEGER_LITERAL:
 767   
     case FLOATING_POINT_LITERAL:
 768   
     case CHARACTER_LITERAL:
 769   
     case STRING_LITERAL:
 770   
     case IDENTIFIER:
 771   
     case LPAREN:
 772   
     case LBRACE:
 773   
     case BANG:
 774   
     case TILDE:
 775   
     case INCR:
 776   
     case DECR:
 777   
     case PLUS:
 778   
     case MINUS:
 779  0
       VariableInitializer();
 780  0
       label_13:
 781   
       while (true) {
 782  0
         if (jj_2_10(2)) {
 783   
           ;
 784   
         } else {
 785  0
           break label_13;
 786   
         }
 787  0
         jj_consume_token(COMMA);
 788  0
         VariableInitializer();
 789   
       }
 790  0
       break;
 791   
     default:
 792  0
       jj_la1[28] = jj_gen;
 793   
       ;
 794   
     }
 795  0
     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
 796   
     case COMMA:
 797  0
       jj_consume_token(COMMA);
 798  0
       break;
 799   
     default:
 800  0
       jj_la1[29] = jj_gen;
 801   
       ;
 802   
     }
 803  0
     jj_consume_token(RBRACE);
 804   
   }
 805   
 
 806  9
   final public void MethodDeclaration() throws ParseException {
 807  9
     label_14:
 808   
     while (true) {
 809  15
       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
 810   
       case ABSTRACT:
 811   
       case FINAL:
 812   
       case NATIVE:
 813   
       case PRIVATE:
 814   
       case PROTECTED:
 815   
       case PUBLIC:
 816   
       case STATIC:
 817   
       case SYNCHRONIZED:
 818   
       case STRICTFP:
 819   
         ;
 820  6
         break;
 821   
       default:
 822  9
         jj_la1[30] = jj_gen;
 823  9
         break label_14;
 824   
       }
 825  6
       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
 826   
       case PUBLIC:
 827  6
         jj_consume_token(PUBLIC);
 828  6
         break;
 829   
       case PROTECTED:
 830  0
         jj_consume_token(PROTECTED);
 831  0
         break;
 832   
       case PRIVATE:
 833  0
         jj_consume_token(PRIVATE);
 834  0
         break;
 835   
       case STATIC:
 836  0
         jj_consume_token(STATIC);
 837  0
         break;
 838   
       case ABSTRACT:
 839  0
         jj_consume_token(ABSTRACT);
 840  0
         break;
 841   
       case FINAL:
 842  0
         jj_consume_token(FINAL);
 843  0
         break;
 844   
       case NATIVE:
 845  0
         jj_consume_token(NATIVE);
 846  0
         break;
 847   
       case SYNCHRONIZED:
 848  0
         jj_consume_token(SYNCHRONIZED);
 849  0
         break;
 850   
       case STRICTFP:
 851  0
         jj_consume_token(STRICTFP);
 852  0
         break;
 853   
       default:
 854  0
         jj_la1[31] = jj_gen;
 855  0
         jj_consume_token(-1);
 856  0
         throw new ParseException();
 857   
       }
 858   
     }
 859  9
     ResultType();
 860  9
     MethodDeclarator();
 861  9
     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
 862   
     case THROWS:
 863  0
       jj_consume_token(THROWS);
 864  0
       NameList();
 865  0
       break;
 866   
     default:
 867  9
       jj_la1[32] = jj_gen;
 868   
       ;
 869   
     }
 870  9
     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
 871   
     case LBRACE:
 872  6
       Block();
 873  6
       break;
 874   
     case SEMICOLON:
 875  3
       jj_consume_token(SEMICOLON);
 876  3
       break;
 877   
     default:
 878  0
       jj_la1[33] = jj_gen;
 879  0
       jj_consume_token(-1);
 880  0
       throw new ParseException();
 881   
     }
 882   
   }
 883   
 
 884  9
   final public void MethodDeclarator() throws ParseException {
 885  9
     jj_consume_token(IDENTIFIER);
 886  9
     FormalParameters();
 887  9
     label_15:
 888   
     while (true) {
 889  9
       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
 890   
       case LBRACKET:
 891   
         ;
 892  0
         break;
 893   
       default:
 894  9
         jj_la1[34] = jj_gen;
 895  9
         break label_15;
 896   
       }
 897  0
       jj_consume_token(LBRACKET);
 898  0
       jj_consume_token(RBRACKET);
 899   
     }
 900   
   }
 901   
 
 902  9
   final public void FormalParameters() throws ParseException {
 903  9
     jj_consume_token(LPAREN);
 904  9
     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
 905   
     case BOOLEAN:
 906   
     case BYTE:
 907   
     case CHAR:
 908   
     case DOUBLE:
 909   
     case FINAL:
 910   
     case FLOAT:
 911   
     case INT:
 912   
     case LONG:
 913   
     case SHORT:
 914   
     case IDENTIFIER:
 915  2
       FormalParameter();
 916  2
       label_16:
 917   
       while (true) {
 918  2
         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
 919   
         case COMMA:
 920   
           ;
 921  0
           break;
 922   
         default:
 923  2
           jj_la1[35] = jj_gen;
 924  2
           break label_16;
 925   
         }
 926  0
         jj_consume_token(COMMA);
 927  0
         FormalParameter();
 928   
       }
 929  2
       break;
 930   
     default:
 931  7
       jj_la1[36] = jj_gen;
 932   
       ;
 933   
     }
 934  9
     jj_consume_token(RPAREN);
 935   
   }
 936   
 
 937  2
   final public void FormalParameter() throws ParseException {
 938  2
     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
 939   
     case FINAL:
 940  0
       jj_consume_token(FINAL);
 941  0
       break;
 942   
     default:
 943  2
       jj_la1[37] = jj_gen;
 944   
       ;
 945   
     }
 946  2
     Type();
 947  2
     VariableDeclaratorId();
 948   
   }
 949   
 
 950  0
   final public void ConstructorDeclaration() throws ParseException {
 951  0
     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
 952   
     case PRIVATE:
 953   
     case PROTECTED:
 954   
     case PUBLIC:
 955  0
       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
 956   
       case PUBLIC:
 957  0
         jj_consume_token(PUBLIC);
 958  0
         break;
 959   
       case PROTECTED:
 960  0
         jj_consume_token(PROTECTED);
 961  0
         break;
 962   
       case PRIVATE:
 963  0
         jj_consume_token(PRIVATE);
 964  0
         break;
 965   
       default:
 966  0
         jj_la1[38] = jj_gen;
 967  0
         jj_consume_token(-1);
 968  0
         throw new ParseException();
 969   
       }
 970  0
       break;
 971   
     default:
 972  0
       jj_la1[39] = jj_gen;
 973   
       ;
 974   
     }
 975  0
     jj_consume_token(IDENTIFIER);
 976  0
     FormalParameters();
 977  0
     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
 978   
     case THROWS:
 979  0
       jj_consume_token(THROWS);
 980  0
       NameList();
 981  0
       break;
 982   
     default:
 983  0
       jj_la1[40] = jj_gen;
 984   
       ;
 985   
     }
 986  0
     jj_consume_token(LBRACE);
 987  0
     if (jj_2_11(2147483647)) {
 988  0
       ExplicitConstructorInvocation();
 989   
     } else {
 990   
       ;
 991   
     }
 992  0
     label_17:
 993   
     while (true) {
 994  0
       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
 995   
       case BOOLEAN:
 996   
       case BREAK:
 997   
       case BYTE:
 998   
       case CHAR:
 999   
       case CLASS:
 1000   
       case CONTINUE:
 1001   
       case DO:
 1002   
       case DOUBLE:
 1003   
       case FALSE:
 1004   
       case FINAL:
 1005   
       case FLOAT:
 1006   
       case FOR:
 1007   
       case IF:
 1008   
       case INT:
 1009   
       case INTERFACE:
 1010   
       case LONG:
 1011   
       case NEW:
 1012   
       case NULL:
 1013   
       case RETURN:
 1014   
       case SHORT:
 1015   
       case SUPER:
 1016   
       case SWITCH:
 1017   
       case SYNCHRONIZED:
 1018   
       case THIS:
 1019   
       case THROW:
 1020   
       case TRUE:
 1021   
       case TRY:
 1022   
       case VOID:
 1023   
       case WHILE:
 1024   
       case ASSERT:
 1025   
       case INTEGER_LITERAL:
 1026   
       case FLOATING_POINT_LITERAL:
 1027   
       case CHARACTER_LITERAL:
 1028   
       case STRING_LITERAL:
 1029   
       case IDENTIFIER:
 1030   
       case LPAREN:
 1031   
       case LBRACE:
 1032   
       case SEMICOLON:
 1033   
       case INCR:
 1034   
       case DECR:
 1035   
         ;
 1036  0
         break;
 1037   
       default:
 1038  0
         jj_la1[41] = jj_gen;
 1039  0
         break label_17;
 1040   
       }
 1041  0
       BlockStatement();
 1042   
     }
 1043  0
     jj_consume_token(RBRACE);
 1044   
   }
 1045   
 
 1046  0
   final public void ExplicitConstructorInvocation() throws ParseException {
 1047  0
     if (jj_2_13(2147483647)) {
 1048  0
       jj_consume_token(THIS);
 1049  0
       Arguments();
 1050  0
       jj_consume_token(SEMICOLON);
 1051   
     } else {
 1052  0
       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
 1053   
       case BOOLEAN:
 1054   
       case BYTE:
 1055   
       case CHAR:
 1056   
       case DOUBLE:
 1057   
       case FALSE:
 1058   
       case FLOAT:
 1059   
       case INT:
 1060   
       case LONG:
 1061   
       case NEW:
 1062   
       case NULL:
 1063   
       case SHORT:
 1064   
       case SUPER:
 1065   
       case THIS:
 1066   
       case TRUE:
 1067   
       case VOID:
 1068   
       case INTEGER_LITERAL:
 1069   
       case FLOATING_POINT_LITERAL:
 1070   
       case CHARACTER_LITERAL:
 1071   
       case STRING_LITERAL:
 1072   
       case IDENTIFIER:
 1073   
       case LPAREN:
 1074  0
         if (jj_2_12(2)) {
 1075  0
           PrimaryExpression();
 1076  0
           jj_consume_token(DOT);
 1077   
         } else {
 1078   
           ;
 1079   
         }
 1080  0
         jj_consume_token(SUPER);
 1081  0
         Arguments();
 1082  0
         jj_consume_token(SEMICOLON);
 1083  0
         break;
 1084   
       default:
 1085  0
         jj_la1[42] = jj_gen;
 1086  0
         jj_consume_token(-1);
 1087  0
         throw new ParseException();
 1088   
       }
 1089   
     }
 1090   
   }
 1091   
 
 1092  0
   final public void Initializer() throws ParseException {
 1093  0
     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
 1094   
     case STATIC:
 1095  0
       jj_consume_token(STATIC);
 1096  0
       break;
 1097   
     default:
 1098  0
       jj_la1[43] = jj_gen;
 1099   
       ;
 1100   
     }
 1101  0
     Block();
 1102   
   }
 1103   
 
 1104   
 /*
 1105   
  * Type, name and expression syntax follows.
 1106   
  */
 1107  12
   final public void Type() throws ParseException {
 1108  12
     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
 1109   
     case BOOLEAN:
 1110   
     case BYTE:
 1111   
     case CHAR:
 1112   
     case DOUBLE:
 1113   
     case FLOAT:
 1114   
     case INT:
 1115   
     case LONG:
 1116   
     case SHORT:
 1117  12
       PrimitiveType();
 1118  12
       break;
 1119   
     case IDENTIFIER:
 1120  0
       Name();
 1121  0
       break;
 1122   
     default:
 1123  0
       jj_la1[44] = jj_gen;
 1124  0
       jj_consume_token(-1);
 1125  0
       throw new ParseException();
 1126   
     }
 1127  12
     label_18:
 1128   
     while (true) {
 1129  12
       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
 1130   
       case LBRACKET:
 1131   
         ;
 1132  0
         break;
 1133   
       default:
 1134  12
         jj_la1[45] = jj_gen;
 1135  12
         break label_18;
 1136   
       }
 1137  0
       jj_consume_token(LBRACKET);
 1138  0
       jj_consume_token(RBRACKET);
 1139   
     }
 1140   
   }
 1141   
 
 1142  12
   final public void PrimitiveType() throws ParseException {
 1143  12
     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
 1144   
     case BOOLEAN:
 1145  3
       jj_consume_token(BOOLEAN);
 1146  3
       break;
 1147   
     case CHAR:
 1148  0
       jj_consume_token(CHAR);
 1149  0
       break;
 1150   
     case BYTE:
 1151  0
       jj_consume_token(BYTE);
 1152  0
       break;
 1153   
     case SHORT:
 1154  0
       jj_consume_token(SHORT);
 1155  0
       break;
 1156   
     case INT:
 1157  9
       jj_consume_token(INT);
 1158  9
       break;
 1159   
     case LONG:
 1160  0
       jj_consume_token(LONG);
 1161  0
       break;
 1162   
     case FLOAT:
 1163  0
       jj_consume_token(FLOAT);
 1164  0
       break;
 1165   
     case DOUBLE:
 1166  0
       jj_consume_token(DOUBLE);
 1167  0
       break;
 1168   
     default:
 1169  0
       jj_la1[46] = jj_gen;
 1170  0
       jj_consume_token(-1);
 1171  0
       throw new ParseException();
 1172   
     }
 1173   
   }
 1174   
 
 1175  9
   final public void ResultType() throws ParseException {
 1176  9
     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
 1177   
     case VOID:
 1178  2
       jj_consume_token(VOID);
 1179  2
       break;
 1180   
     case BOOLEAN:
 1181   
     case BYTE:
 1182   
     case CHAR:
 1183   
     case DOUBLE:
 1184   
     case FLOAT:
 1185   
     case INT:
 1186   
     case LONG:
 1187   
     case SHORT:
 1188   
     case IDENTIFIER:
 1189  7
       Type();
 1190  7
       break;
 1191   
     default:
 1192  0
       jj_la1[47] = jj_gen;
 1193  0
       jj_consume_token(-1);
 1194  0
       throw new ParseException();
 1195   
     }
 1196   
   }
 1197   
 
 1198  29
   final public ASTName Name() throws ParseException {
 1199  29
   ASTName jjtThis = new ASTName();
 1200  29
   Token t;
 1201  29
     t = jj_consume_token(IDENTIFIER);
 1202  29
                    jjtThis.addToName(t.image);
 1203  29
     label_19:
 1204   
     while (true) {
 1205  49
       if (jj_2_14(2)) {
 1206   
         ;
 1207   
       } else {
 1208  29
         break label_19;
 1209   
       }
 1210  20
       jj_consume_token(DOT);
 1211  20
       t = jj_consume_token(IDENTIFIER);
 1212  20
                                       jjtThis.addToName("." + t.image);
 1213   
     }
 1214  29
     {if (true) return jjtThis;}
 1215  0
     throw new Error("Missing return statement in function");
 1216   
   }
 1217   
 
 1218  8
   final public ASTNameList NameList() throws ParseException {
 1219  8
   ASTNameList jjtThis = new ASTNameList();
 1220  8
   ASTName name = null;
 1221  8
     name = Name();
 1222  8
                   jjtThis.addName(name);
 1223  8
     label_20:
 1224   
     while (true) {
 1225  10
       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
 1226   
       case COMMA:
 1227   
         ;
 1228  2
         break;
 1229   
       default:
 1230  8
         jj_la1[48] = jj_gen;
 1231  8
         break label_20;
 1232   
       }
 1233  2
       jj_consume_token(COMMA);
 1234  2
       name = Name();
 1235  2
                         jjtThis.addName(name);
 1236   
     }
 1237  8
     {if (true) return jjtThis;}
 1238  0
     throw new Error("Missing return statement in function");
 1239   
   }
 1240   
 
 1241   
 /*
 1242   
  * Expression syntax follows.
 1243   
  */
 1244  8
   final public void Expression() throws ParseException {
 1245  8
     ConditionalExpression();
 1246  8
     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
 1247   
     case ASSIGN:
 1248   
     case PLUSASSIGN:
 1249   
     case MINUSASSIGN:
 1250   
     case STARASSIGN:
 1251   
     case SLASHASSIGN:
 1252   
     case ANDASSIGN:
 1253   
     case ORASSIGN:
 1254   
     case XORASSIGN:
 1255   
     case REMASSIGN:
 1256   
     case LSHIFTASSIGN:
 1257   
     case RSIGNEDSHIFTASSIGN:
 1258   
     case RUNSIGNEDSHIFTASSIGN:
 1259  0
       AssignmentOperator();
 1260  0
       Expression();
 1261  0
       break;
 1262   
     default:
 1263  8
       jj_la1[49] = jj_gen;
 1264   
       ;
 1265   
     }
 1266   
   }
 1267   
 
 1268  1
   final public void AssignmentOperator() throws ParseException {
 1269  1
     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
 1270   
     case ASSIGN:
 1271  1
       jj_consume_token(ASSIGN);
 1272  1
       break;
 1273   
     case STARASSIGN:
 1274  0
       jj_consume_token(STARASSIGN);
 1275  0
       break;
 1276   
     case SLASHASSIGN:
 1277  0
       jj_consume_token(SLASHASSIGN);
 1278  0
       break;
 1279   
     case REMASSIGN:
 1280  0
       jj_consume_token(REMASSIGN);
 1281  0
       break;
 1282   
     case PLUSASSIGN:
 1283  0
       jj_consume_token(PLUSASSIGN);
 1284  0
       break;
 1285   
     case MINUSASSIGN:
 1286  0
       jj_consume_token(MINUSASSIGN);
 1287  0
       break;
 1288   
     case LSHIFTASSIGN:
 1289  0
       jj_consume_token(LSHIFTASSIGN);
 1290  0
       break;
 1291   
     case RSIGNEDSHIFTASSIGN:
 1292  0
       jj_consume_token(RSIGNEDSHIFTASSIGN);
 1293  0
       break;
 1294   
     case RUNSIGNEDSHIFTASSIGN:
 1295  0
       jj_consume_token(RUNSIGNEDSHIFTASSIGN);
 1296  0
       break;
 1297   
     case ANDASSIGN:
 1298  0
       jj_consume_token(ANDASSIGN);
 1299  0
       break;
 1300   
     case XORASSIGN:
 1301  0
       jj_consume_token(XORASSIGN);
 1302  0
       break;
 1303   
     case ORASSIGN:
 1304  0
       jj_consume_token(ORASSIGN);
 1305  0
       break;
 1306   
     default:
 1307  0
       jj_la1[50] = jj_gen;
 1308  0
       jj_consume_token(-1);
 1309  0
       throw new ParseException();
 1310   
     }
 1311   
   }
 1312   
 
 1313  8
   final public void ConditionalExpression() throws ParseException {
 1314  8
     ConditionalOrExpression();
 1315  8
     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
 1316   
     case HOOK:
 1317  0
       jj_consume_token(HOOK);
 1318  0
       Expression();
 1319  0
       jj_consume_token(COLON);
 1320  0
       ConditionalExpression();
 1321  0
       break;
 1322   
     default:
 1323  8
       jj_la1[51] = jj_gen;
 1324   
       ;
 1325   
     }
 1326   
   }
 1327   
 
 1328  8
   final public void ConditionalOrExpression() throws ParseException {
 1329  8
     ConditionalAndExpression();
 1330  8
     label_21:
 1331   
     while (true) {
 1332  8
       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
 1333   
       case SC_OR:
 1334   
         ;
 1335  0
         break;
 1336   
       default:
 1337  8
         jj_la1[52] = jj_gen;
 1338  8
         break label_21;
 1339   
       }
 1340  0
       jj_consume_token(SC_OR);
 1341  0
       ConditionalAndExpression();
 1342   
     }
 1343   
   }
 1344   
 
 1345  8
   final public void ConditionalAndExpression() throws ParseException {
 1346  8
     InclusiveOrExpression();
 1347  8
     label_22:
 1348   
     while (true) {
 1349  8
       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
 1350   
       case SC_AND:
 1351   
         ;
 1352  0
         break;
 1353   
       default:
 1354  8
         jj_la1[53] = jj_gen;
 1355  8
         break label_22;
 1356   
       }
 1357  0
       jj_consume_token(SC_AND);
 1358  0
       InclusiveOrExpression();
 1359   
     }
 1360   
   }
 1361   
 
 1362  8
   final public void InclusiveOrExpression() throws ParseException {
 1363  8
     ExclusiveOrExpression();
 1364  8
     label_23:
 1365   
     while (true) {
 1366  8
       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
 1367   
       case BIT_OR:
 1368   
         ;
 1369  0
         break;
 1370   
       default:
 1371  8
         jj_la1[54] = jj_gen;
 1372  8
         break label_23;
 1373   
       }
 1374  0
       jj_consume_token(BIT_OR);
 1375  0
       ExclusiveOrExpression();
 1376   
     }
 1377   
   }
 1378   
 
 1379  8
   final public void ExclusiveOrExpression() throws ParseException {
 1380  8
     AndExpression();
 1381  8
     label_24:
 1382   
     while (true) {
 1383  8
       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
 1384   
       case XOR:
 1385   
         ;
 1386  0
         break;
 1387   
       default:
 1388  8
         jj_la1[55] = jj_gen;
 1389  8
         break label_24;
 1390   
       }
 1391  0
       jj_consume_token(XOR);
 1392  0
       AndExpression();
 1393   
     }
 1394   
   }
 1395   
 
 1396  8
   final public void AndExpression() throws ParseException {
 1397  8
     EqualityExpression();
 1398  8
     label_25:
 1399   
     while (true) {
 1400  8
       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
 1401   
       case BIT_AND:
 1402   
         ;
 1403  0
         break;
 1404   
       default:
 1405  8
         jj_la1[56] = jj_gen;
 1406  8
         break label_25;
 1407   
       }
 1408  0
       jj_consume_token(BIT_AND);
 1409  0
       EqualityExpression();
 1410   
     }
 1411   
   }
 1412   
 
 1413  8
   final public void EqualityExpression() throws ParseException {
 1414  8
     InstanceOfExpression();
 1415  8
     label_26:
 1416   
     while (true) {
 1417  8
       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
 1418   
       case EQ:
 1419   
       case NE:
 1420   
         ;
 1421  0
         break;
 1422   
       default:
 1423  8
         jj_la1[57] = jj_gen;
 1424  8
         break label_26;
 1425   
       }
 1426  0
       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
 1427   
       case EQ:
 1428  0
         jj_consume_token(EQ);
 1429  0
         break;
 1430   
       case NE:
 1431  0
         jj_consume_token(NE);
 1432  0
         break;
 1433   
       default:
 1434  0
         jj_la1[58] = jj_gen;
 1435  0
         jj_consume_token(-1);
 1436  0
         throw new ParseException();
 1437   
       }
 1438  0
       InstanceOfExpression();
 1439   
     }
 1440   
   }
 1441   
 
 1442  8
   final public void InstanceOfExpression() throws ParseException {
 1443  8
     RelationalExpression();
 1444  8
     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
 1445   
     case INSTANCEOF:
 1446  0
       jj_consume_token(INSTANCEOF);
 1447  0
       Type();
 1448  0
       break;
 1449   
     default:
 1450  8
       jj_la1[59] = jj_gen;
 1451   
       ;
 1452   
     }
 1453   
   }
 1454   
 
 1455  8
   final public void RelationalExpression() throws ParseException {
 1456  8
     ShiftExpression();
 1457  8
     label_27:
 1458   
     while (true) {
 1459  8
       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
 1460   
       case GT:
 1461   
       case LT:
 1462   
       case LE:
 1463   
       case GE:
 1464   
         ;
 1465  0
         break;
 1466   
       default:
 1467  8
         jj_la1[60] = jj_gen;
 1468  8
         break label_27;
 1469   
       }
 1470  0
       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
 1471   
       case LT:
 1472  0
         jj_consume_token(LT);
 1473  0
         break;
 1474   
       case GT:
 1475  0
         jj_consume_token(GT);
 1476  0
         break;
 1477   
       case LE:
 1478  0
         jj_consume_token(LE);
 1479  0
         break;
 1480   
       case GE:
 1481  0
         jj_consume_token(GE);
 1482  0
         break;
 1483   
       default:
 1484  0
         jj_la1[61] = jj_gen;
 1485  0
         jj_consume_token(-1);
 1486  0
         throw new ParseException();
 1487   
       }
 1488  0
       ShiftExpression();
 1489   
     }
 1490   
   }
 1491   
 
 1492  8
   final public void ShiftExpression() throws ParseException {
 1493  8
     AdditiveExpression();
 1494  8
     label_28:
 1495   
     while (true) {
 1496  8
       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
 1497   
       case LSHIFT:
 1498   
       case RSIGNEDSHIFT:
 1499   
       case RUNSIGNEDSHIFT:
 1500   
         ;
 1501  0
         break;
 1502   
       default:
 1503  8
         jj_la1[62] = jj_gen;
 1504  8
         break label_28;
 1505   
       }
 1506  0
       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
 1507   
       case LSHIFT:
 1508  0
         jj_consume_token(LSHIFT);
 1509  0
         break;
 1510   
       case RSIGNEDSHIFT:
 1511  0
         jj_consume_token(RSIGNEDSHIFT);
 1512  0
         break;
 1513   
       case RUNSIGNEDSHIFT:
 1514  0
         jj_consume_token(RUNSIGNEDSHIFT);
 1515  0
         break;
 1516   
       default:
 1517  0
         jj_la1[63] = jj_gen;
 1518  0
         jj_consume_token(-1);
 1519  0
         throw new ParseException();
 1520   
       }
 1521  0
       AdditiveExpression();
 1522   
     }
 1523   
   }
 1524   
 
 1525  8
   final public void AdditiveExpression() throws ParseException {
 1526  8
     MultiplicativeExpression();
 1527  8
     label_29:
 1528   
     while (true) {
 1529  8
       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
 1530   
       case PLUS:
 1531   
       case MINUS:
 1532   
         ;
 1533  0
         break;
 1534   
       default:
 1535  8
         jj_la1[64] = jj_gen;
 1536  8
         break label_29;
 1537   
       }
 1538  0
       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
 1539   
       case PLUS:
 1540  0
         jj_consume_token(PLUS);
 1541  0
         break;
 1542   
       case MINUS:
 1543  0
         jj_consume_token(MINUS);
 1544  0
         break;
 1545   
       default:
 1546  0
         jj_la1[65] = jj_gen;
 1547  0
         jj_consume_token(-1);
 1548  0
         throw new ParseException();
 1549   
       }
 1550  0
       MultiplicativeExpression();
 1551   
     }
 1552   
   }
 1553   
 
 1554  8
   final public void MultiplicativeExpression() throws ParseException {
 1555  8
     UnaryExpression();
 1556  8
     label_30:
 1557   
     while (true) {
 1558  8
       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
 1559   
       case STAR:
 1560   
       case SLASH:
 1561   
       case REM:
 1562   
         ;
 1563  0
         break;
 1564   
       default:
 1565  8
         jj_la1[66] = jj_gen;
 1566  8
         break label_30;
 1567   
       }
 1568  0
       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
 1569   
       case STAR:
 1570  0
         jj_consume_token(STAR);
 1571  0
         break;
 1572   
       case SLASH:
 1573  0
         jj_consume_token(SLASH);
 1574  0
         break;
 1575   
       case REM:
 1576  0
         jj_consume_token(REM);
 1577  0
         break;
 1578   
       default:
 1579  0
         jj_la1[67] = jj_gen;
 1580  0
         jj_consume_token(-1);
 1581  0
         throw new ParseException();
 1582   
       }
 1583  0
       UnaryExpression();
 1584   
     }
 1585   
   }
 1586   
 
 1587  8
   final public void UnaryExpression() throws ParseException {
 1588  8
     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
 1589   
     case PLUS:
 1590   
     case MINUS:
 1591  0
       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
 1592   
       case PLUS:
 1593  0
         jj_consume_token(PLUS);
 1594  0
         break;
 1595   
       case MINUS:
 1596  0
         jj_consume_token(MINUS);
 1597  0
         break;
 1598   
       default:
 1599  0
         jj_la1[68] = jj_gen;
 1600  0
         jj_consume_token(-1);
 1601  0
         throw new ParseException();
 1602   
       }
 1603  0
       UnaryExpression();
 1604  0
       break;
 1605   
     case INCR:
 1606  0
       PreIncrementExpression();
 1607  0
       break;
 1608   
     case DECR:
 1609  0
       PreDecrementExpression();
 1610  0
       break;
 1611   
     case BOOLEAN:
 1612   
     case BYTE:
 1613   
     case CHAR:
 1614   
     case DOUBLE:
 1615   
     case FALSE:
 1616   
     case FLOAT:
 1617   
     case INT:
 1618   
     case LONG:
 1619   
     case NEW:
 1620   
     case NULL:
 1621   
     case SHORT:
 1622   
     case SUPER:
 1623   
     case THIS:
 1624   
     case TRUE:
 1625   
     case VOID:
 1626   
     case INTEGER_LITERAL:
 1627   
     case FLOATING_POINT_LITERAL:
 1628   
     case CHARACTER_LITERAL:
 1629   
     case STRING_LITERAL:
 1630   
     case IDENTIFIER:
 1631   
     case LPAREN:
 1632   
     case BANG:
 1633   
     case TILDE:
 1634  8
       UnaryExpressionNotPlusMinus();
 1635  8
       break;
 1636   
     default:
 1637  0
       jj_la1[69] = jj_gen;
 1638  0
       jj_consume_token(-1);
 1639  0
       throw new ParseException();
 1640   
     }
 1641   
   }
 1642   
 
 1643  0
   final public void PreIncrementExpression() throws ParseException {
 1644  0
     jj_consume_token(INCR);
 1645  0
     PrimaryExpression();
 1646   
   }
 1647   
 
 1648  0
   final public void PreDecrementExpression() throws ParseException {
 1649  0
     jj_consume_token(DECR);
 1650  0
     PrimaryExpression();
 1651   
   }
 1652   
 
 1653  8
   final public void UnaryExpressionNotPlusMinus() throws ParseException {
 1654  8
     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
 1655   
     case BANG:
 1656   
     case TILDE:
 1657  0
       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
 1658   
       case TILDE:
 1659  0
         jj_consume_token(TILDE);
 1660  0
         break;
 1661   
       case BANG:
 1662  0
         jj_consume_token(BANG);
 1663  0
         break;
 1664   
       default:
 1665  0
         jj_la1[70] = jj_gen;
 1666  0
         jj_consume_token(-1);
 1667  0
         throw new ParseException();
 1668   
       }
 1669  0
       UnaryExpression();
 1670  0
       break;
 1671   
     default:
 1672  8
       jj_la1[71] = jj_gen;
 1673  8
       if (jj_2_15(2147483647)) {
 1674  0
         CastExpression();
 1675   
       } else {
 1676  8
         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
 1677   
         case BOOLEAN:
 1678   
         case BYTE:
 1679   
         case CHAR:
 1680   
         case DOUBLE:
 1681   
         case FALSE:
 1682   
         case FLOAT:
 1683   
         case INT:
 1684   
         case LONG:
 1685   
         case NEW:
 1686   
         case NULL:
 1687   
         case SHORT:
 1688   
         case SUPER:
 1689   
         case THIS:
 1690   
         case TRUE:
 1691   
         case VOID:
 1692   
         case INTEGER_LITERAL:
 1693   
         case FLOATING_POINT_LITERAL:
 1694   
         case CHARACTER_LITERAL:
 1695   
         case STRING_LITERAL:
 1696   
         case IDENTIFIER:
 1697   
         case LPAREN:
 1698  8
           PostfixExpression();
 1699  8
           break;
 1700   
         default:
 1701  0
           jj_la1[72] = jj_gen;
 1702  0
           jj_consume_token(-1);
 1703  0
           throw new ParseException();
 1704   
         }
 1705   
       }
 1706   
     }
 1707   
   }
 1708   
 
 1709   
 // This production is to determine lookahead only.  The LOOKAHEAD specifications
 1710   
 // below are not used, but they are there just to indicate that we know about
 1711   
 // this.
 1712  0
   final public void CastLookahead() throws ParseException {
 1713  0
     if (jj_2_16(2)) {
 1714  0
       jj_consume_token(LPAREN);
 1715  0
       PrimitiveType();
 1716  0
     } else if (jj_2_17(2147483647)) {
 1717  0
       jj_consume_token(LPAREN);
 1718  0
       Name();
 1719  0
       jj_consume_token(LBRACKET);
 1720  0
       jj_consume_token(RBRACKET);
 1721   
     } else {
 1722  0
       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
 1723   
       case LPAREN:
 1724  0
         jj_consume_token(LPAREN);
 1725  0
         Name();
 1726  0
         jj_consume_token(RPAREN);
 1727  0
         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
 1728   
         case TILDE:
 1729  0
           jj_consume_token(TILDE);
 1730  0
           break;
 1731   
         case BANG:
 1732  0
           jj_consume_token(BANG);
 1733  0
           break;
 1734   
         case LPAREN:
 1735  0
           jj_consume_token(LPAREN);
 1736  0
           break;
 1737   
         case IDENTIFIER:
 1738  0
           jj_consume_token(IDENTIFIER);
 1739  0
           break;
 1740   
         case THIS:
 1741  0
           jj_consume_token(THIS);
 1742  0
           break;
 1743   
         case SUPER:
 1744  0
           jj_consume_token(SUPER);
 1745  0
           break;
 1746   
         case NEW:
 1747  0
           jj_consume_token(NEW);
 1748  0
           break;
 1749   
         case FALSE:
 1750   
         case NULL:
 1751   
         case TRUE:
 1752   
         case INTEGER_LITERAL:
 1753   
         case FLOATING_POINT_LITERAL:
 1754   
         case CHARACTER_LITERAL:
 1755   
         case STRING_LITERAL:
 1756  0
           Literal();
 1757  0
           break;
 1758   
         default:
 1759  0
           jj_la1[73] = jj_gen;
 1760  0
           jj_consume_token(-1);
 1761  0
           throw new ParseException();
 1762   
         }
 1763  0
         break;
 1764   
       default:
 1765  0
         jj_la1[74] = jj_gen;
 1766  0
         jj_consume_token(-1);
 1767  0
         throw new ParseException();
 1768   
       }
 1769   
     }
 1770   
   }
 1771   
 
 1772  8
   final public void PostfixExpression() throws ParseException {
 1773  8
     PrimaryExpression();
 1774  8
     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
 1775   
     case INCR:
 1776   
     case DECR:
 1777  0
       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
 1778   
       case INCR:
 1779  0
         jj_consume_token(INCR);
 1780  0
         break;
 1781   
       case DECR:
 1782  0
         jj_consume_token(DECR);
 1783  0
         break;
 1784   
       default:
 1785  0
         jj_la1[75] = jj_gen;
 1786  0
         jj_consume_token(-1);
 1787  0
         throw new ParseException();
 1788   
       }
 1789  0
       break;
 1790   
     default:
 1791  8
       jj_la1[76] = jj_gen;
 1792   
       ;
 1793   
     }
 1794   
   }
 1795   
 
 1796  0
   final public void CastExpression() throws ParseException {
 1797  0
     if (jj_2_18(2147483647)) {
 1798  0
       jj_consume_token(LPAREN);
 1799  0
       Type();
 1800  0
       jj_consume_token(RPAREN);
 1801  0
       UnaryExpression();
 1802   
     } else {
 1803  0
       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
 1804   
       case LPAREN:
 1805  0
         jj_consume_token(LPAREN);
 1806  0
         Type();
 1807  0
         jj_consume_token(RPAREN);
 1808  0
         UnaryExpressionNotPlusMinus();
 1809  0
         break;
 1810   
       default:
 1811  0
         jj_la1[77] = jj_gen;
 1812  0
         jj_consume_token(-1);
 1813  0
         throw new ParseException();
 1814   
       }
 1815   
     }
 1816   
   }
 1817   
 
 1818  11
   final public void PrimaryExpression() throws ParseException {
 1819  11
     PrimaryPrefix();
 1820  11
     label_31:
 1821   
     while (true) {
 1822  14
       if (jj_2_19(2)) {
 1823   
         ;
 1824   
       } else {
 1825  11
         break label_31;
 1826   
       }
 1827  3
       PrimarySuffix();
 1828   
     }
 1829   
   }
 1830   
 
 1831  11
   final public void PrimaryPrefix() throws ParseException {
 1832  11
     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
 1833   
     case FALSE:
 1834   
     case NULL:
 1835   
     case TRUE:
 1836   
     case INTEGER_LITERAL:
 1837   
     case FLOATING_POINT_LITERAL:
 1838   
     case CHARACTER_LITERAL:
 1839   
     case STRING_LITERAL:
 1840  4
       Literal();
 1841  4
       break;
 1842   
     case THIS:
 1843  0
       jj_consume_token(THIS);
 1844  0
       break;
 1845   
     case SUPER:
 1846  0
       jj_consume_token(SUPER);
 1847  0
       jj_consume_token(DOT);
 1848  0
       jj_consume_token(IDENTIFIER);
 1849  0
       break;
 1850   
     case LPAREN:
 1851  0
       jj_consume_token(LPAREN);
 1852  0
       Expression();
 1853  0
       jj_consume_token(RPAREN);
 1854  0
       break;
 1855   
     case NEW:
 1856  0
       AllocationExpression();
 1857  0
       break;
 1858   
     default:
 1859  7
       jj_la1[78] = jj_gen;
 1860  7
       if (jj_2_20(2147483647)) {
 1861  0
         ResultType();
 1862  0
         jj_consume_token(DOT);
 1863  0
         jj_consume_token(CLASS);
 1864   
       } else {
 1865  7
         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
 1866   
         case IDENTIFIER:
 1867  7
           Name();
 1868  7
           break;
 1869   
         default:
 1870  0
           jj_la1[79] = jj_gen;
 1871  0
           jj_consume_token(-1);
 1872  0
           throw new ParseException();
 1873   
         }
 1874   
       }
 1875   
     }
 1876   
   }
 1877   
 
 1878   
 /* Add "." "super" to be compatible with Java 1.2, 
 1879   
  * Modified by Marco Savard
 1880   
  */
 1881  3
   final public void PrimarySuffix() throws ParseException {
 1882  3
     if (jj_2_21(2)) {
 1883  0
       jj_consume_token(DOT);
 1884  0
       jj_consume_token(THIS);
 1885  3
     } else if (jj_2_22(2)) {
 1886  0
       jj_consume_token(DOT);
 1887  0
       jj_consume_token(SUPER);
 1888  3
     } else if (jj_2_23(2)) {
 1889  0
       jj_consume_token(DOT);
 1890  0
       AllocationExpression();
 1891   
     } else {
 1892  3
       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
 1893   
       case LBRACKET:
 1894  0
         jj_consume_token(LBRACKET);
 1895  0
         Expression();
 1896  0
         jj_consume_token(RBRACKET);
 1897  0
         break;
 1898   
       case DOT:
 1899  1
         jj_consume_token(DOT);
 1900  1
         jj_consume_token(IDENTIFIER);
 1901  1
         break;
 1902   
       case LPAREN:
 1903  2
         Arguments();
 1904  2
         break;
 1905   
       default:
 1906  0
         jj_la1[80] = jj_gen;
 1907  0
         jj_consume_token(-1);
 1908  0
         throw new ParseException();
 1909   
       }
 1910   
     }
 1911   
   }
 1912   
 
 1913  4
   final public void Literal() throws ParseException {
 1914  4
     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
 1915   
     case INTEGER_LITERAL:
 1916  2
       jj_consume_token(INTEGER_LITERAL);
 1917  2
       break;
 1918   
     case FLOATING_POINT_LITERAL:
 1919  0
       jj_consume_token(FLOATING_POINT_LITERAL);
 1920  0
       break;
 1921   
     case CHARACTER_LITERAL:
 1922  0
       jj_consume_token(CHARACTER_LITERAL);
 1923  0
       break;
 1924   
     case STRING_LITERAL:
 1925  0
       jj_consume_token(STRING_LITERAL);
 1926  0
       break;
 1927   
     case FALSE:
 1928   
     case TRUE:
 1929  2
       BooleanLiteral();
 1930  2
       break;
 1931   
     case NULL:
 1932  0
       NullLiteral();
 1933  0
       break;
 1934   
     default:
 1935  0
       jj_la1[81] = jj_gen;
 1936  0
       jj_consume_token(-1);
 1937  0
       throw new ParseException();
 1938   
     }
 1939   
   }
 1940   
 
 1941  2
   final public void BooleanLiteral() throws ParseException {
 1942  2
     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
 1943   
     case TRUE:
 1944  1
       jj_consume_token(TRUE);
 1945  1
       break;
 1946   
     case FALSE:
 1947  1
       jj_consume_token(FALSE);
 1948  1
       break;
 1949   
     default:
 1950  0
       jj_la1[82] = jj_gen;
 1951  0
       jj_consume_token(-1);
 1952  0
       throw new ParseException();
 1953   
     }
 1954   
   }
 1955   
 
 1956  0
   final public void NullLiteral() throws ParseException {
 1957  0
     jj_consume_token(NULL);
 1958   
   }
 1959   
 
 1960  2
   final public void Arguments() throws ParseException {
 1961  2
     jj_consume_token(LPAREN);
 1962  2
     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
 1963   
     case BOOLEAN:
 1964   
     case BYTE:
 1965   
     case CHAR:
 1966   
     case DOUBLE:
 1967   
     case FALSE:
 1968   
     case FLOAT:
 1969   
     case INT:
 1970   
     case LONG:
 1971   
     case NEW:
 1972   
     case NULL:
 1973   
     case SHORT:
 1974   
     case SUPER:
 1975   
     case THIS:
 1976   
     case TRUE:
 1977   
     case VOID:
 1978   
     case INTEGER_LITERAL:
 1979   
     case FLOATING_POINT_LITERAL:
 1980   
     case CHARACTER_LITERAL:
 1981   
     case STRING_LITERAL:
 1982   
     case IDENTIFIER:
 1983   
     case LPAREN:
 1984   
     case BANG:
 1985   
     case TILDE:
 1986   
     case INCR:
 1987   
     case DECR:
 1988   
     case PLUS:
 1989   
     case MINUS:
 1990  0
       ArgumentList();
 1991  0
       break;
 1992   
     default:
 1993  2
       jj_la1[83] = jj_gen;
 1994   
       ;
 1995   
     }
 1996  2
     jj_consume_token(RPAREN);
 1997   
   }
 1998   
 
 1999  0
   final public void ArgumentList() throws ParseException {
 2000  0
     Expression();
 2001  0
     label_32:
 2002   
     while (true) {
 2003  0
       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
 2004   
       case COMMA:
 2005   
         ;
 2006  0
         break;
 2007   
       default:
 2008  0
         jj_la1[84] = jj_gen;
 2009  0
         break label_32;
 2010   
       }
 2011  0
       jj_consume_token(COMMA);
 2012  0
       Expression();
 2013   
     }
 2014   
   }
 2015   
 
 2016  0
   final public void AllocationExpression() throws ParseException {
 2017  0
     if (jj_2_24(2)) {
 2018  0
       jj_consume_token(NEW);
 2019  0
       PrimitiveType();
 2020  0
       ArrayDimsAndInits();
 2021   
     } else {
 2022  0
       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
 2023   
       case NEW:
 2024  0
         jj_consume_token(NEW);
 2025  0
         Name();
 2026  0
         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
 2027   
         case LBRACKET:
 2028  0
           ArrayDimsAndInits();
 2029  0
           break;
 2030   
         case LPAREN:
 2031  0
           Arguments();
 2032  0
           switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
 2033   
           case LBRACE:
 2034  0
             ClassBody();
 2035  0
             break;
 2036   
           default:
 2037  0
             jj_la1[85] = jj_gen;
 2038   
             ;
 2039   
           }
 2040  0
           break;
 2041   
         default:
 2042  0
           jj_la1[86] = jj_gen;
 2043  0
           jj_consume_token(-1);
 2044  0
           throw new ParseException();
 2045   
         }
 2046  0
         break;
 2047   
       default:
 2048  0
         jj_la1[87] = jj_gen;
 2049  0
         jj_consume_token(-1);
 2050  0
         throw new ParseException();
 2051   
       }
 2052   
     }
 2053   
   }
 2054   
 
 2055   
 /*
 2056   
  * The second LOOKAHEAD specification below is to parse to PrimarySuffix
 2057   
  * if there is an expression between the "[...]".
 2058   
  */
 2059  0
   final public void ArrayDimsAndInits() throws ParseException {
 2060  0
     if (jj_2_27(2)) {
 2061  0
       label_33:
 2062   
       while (true) {
 2063  0
         jj_consume_token(LBRACKET);
 2064  0
         Expression();
 2065  0
         jj_consume_token(RBRACKET);
 2066  0
         if (jj_2_25(2)) {
 2067   
           ;
 2068   
         } else {
 2069  0
           break label_33;
 2070   
         }
 2071   
       }
 2072  0
       label_34:
 2073   
       while (true) {
 2074  0
         if (jj_2_26(2)) {
 2075   
           ;
 2076   
         } else {
 2077  0
           break label_34;
 2078   
         }
 2079  0
         jj_consume_token(LBRACKET);
 2080  0
         jj_consume_token(RBRACKET);
 2081   
       }
 2082   
     } else {
 2083  0
       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
 2084   
       case LBRACKET:
 2085  0
         label_35:
 2086   
         while (true) {
 2087  0
           jj_consume_token(LBRACKET);
 2088  0
           jj_consume_token(RBRACKET);
 2089  0
           switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
 2090   
           case LBRACKET:
 2091   
             ;
 2092  0
             break;
 2093   
           default:
 2094  0
             jj_la1[88] = jj_gen;
 2095  0
             break label_35;
 2096   
           }
 2097   
         }
 2098  0
         ArrayInitializer();
 2099  0
         break;
 2100   
       default:
 2101  0
         jj_la1[89] = jj_gen;
 2102  0
         jj_consume_token(-1);
 2103  0
         throw new ParseException();
 2104   
       }
 2105   
     }
 2106   
   }
 2107   
 
 2108   
 /*
 2109   
  * Statement syntax follows.
 2110   
  */
 2111  7
   final public void Statement() throws ParseException {
 2112  7
     if (jj_2_28(2)) {
 2113  0
       LabeledStatement();
 2114   
     } else {
 2115  7
       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
 2116   
       case LBRACE:
 2117  0
         Block();
 2118  0
         break;
 2119   
       case SEMICOLON:
 2120  0
         EmptyStatement();
 2121  0
         break;
 2122   
       case BOOLEAN:
 2123   
       case BYTE:
 2124   
       case CHAR:
 2125   
       case DOUBLE:
 2126   
       case FALSE:
 2127   
       case FLOAT:
 2128   
       case INT:
 2129   
       case LONG:
 2130   
       case NEW:
 2131   
       case NULL:
 2132   
       case SHORT:
 2133   
       case SUPER:
 2134   
       case THIS:
 2135   
       case TRUE:
 2136   
       case VOID:
 2137   
       case INTEGER_LITERAL:
 2138   
       case FLOATING_POINT_LITERAL:
 2139   
       case CHARACTER_LITERAL:
 2140   
       case STRING_LITERAL:
 2141   
       case IDENTIFIER:
 2142   
       case LPAREN:
 2143   
       case INCR:
 2144   
       case DECR:
 2145  3
         StatementExpression();
 2146  3
         jj_consume_token(SEMICOLON);
 2147  3
         break;
 2148   
       case SWITCH:
 2149  0
         SwitchStatement();
 2150  0
         break;
 2151   
       case IF:
 2152  0
         IfStatement();
 2153  0
         break;
 2154   
       case WHILE:
 2155  0
         WhileStatement();
 2156  0
         break;
 2157   
       case DO:
 2158  0
         DoStatement();
 2159  0
         break;
 2160   
       case FOR:
 2161  0
         ForStatement();
 2162  0
         break;
 2163   
       case BREAK:
 2164  0
         BreakStatement();
 2165  0
         break;
 2166   
       case CONTINUE:
 2167  0
         ContinueStatement();
 2168  0
         break;
 2169   
       case RETURN:
 2170  4
         ReturnStatement();
 2171  4
         break;
 2172   
       case THROW:
 2173  0
         ThrowStatement();
 2174  0
         break;
 2175   
       case SYNCHRONIZED:
 2176  0
         SynchronizedStatement();
 2177  0
         break;
 2178   
       case TRY:
 2179  0
         TryStatement();
 2180  0
         break;
 2181   
       case ASSERT:
 2182  0
         AssertStatement();
 2183  0
         break;
 2184   
       default:
 2185  0
         jj_la1[90] = jj_gen;
 2186  0
         jj_consume_token(-1);
 2187  0
         throw new ParseException();
 2188   
       }
 2189   
     }
 2190   
   }
 2191   
 
 2192  0
   final public void LabeledStatement() throws ParseException {
 2193  0
     jj_consume_token(IDENTIFIER);
 2194  0
     jj_consume_token(COLON);
 2195  0
     Statement();
 2196   
   }
 2197   
 
 2198  6
   final public void Block() throws ParseException {
 2199  6
     jj_consume_token(LBRACE);
 2200  6
     label_36:
 2201   
     while (true) {
 2202  13
       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
 2203   
       case BOOLEAN:
 2204   
       case BREAK:
 2205   
       case BYTE:
 2206   
       case CHAR:
 2207   
       case CLASS:
 2208   
       case CONTINUE:
 2209   
       case DO:
 2210   
       case DOUBLE:
 2211   
       case FALSE:
 2212   
       case FINAL:
 2213   
       case FLOAT:
 2214   
       case FOR:
 2215   
       case IF:
 2216   
       case INT:
 2217   
       case INTERFACE:
 2218   
       case LONG:
 2219   
       case NEW:
 2220   
       case NULL:
 2221   
       case RETURN:
 2222   
       case SHORT:
 2223   
       case SUPER:
 2224   
       case SWITCH:
 2225   
       case SYNCHRONIZED:
 2226   
       case THIS:
 2227   
       case THROW:
 2228   
       case TRUE:
 2229   
       case TRY:
 2230   
       case VOID:
 2231   
       case WHILE:
 2232   
       case ASSERT:
 2233   
       case INTEGER_LITERAL:
 2234   
       case FLOATING_POINT_LITERAL:
 2235   
       case CHARACTER_LITERAL:
 2236   
       case STRING_LITERAL:
 2237   
       case IDENTIFIER:
 2238   
       case LPAREN:
 2239   
       case LBRACE:
 2240   
       case SEMICOLON:
 2241   
       case INCR:
 2242   
       case DECR:
 2243   
         ;
 2244  7
         break;
 2245   
       default:
 2246  6
         jj_la1[91] = jj_gen;
 2247  6
         break label_36;
 2248   
       }
 2249  7
       BlockStatement();
 2250   
     }
 2251  6
     jj_consume_token(RBRACE);
 2252   
   }
 2253   
 
 2254  7
   final public void BlockStatement() throws ParseException {
 2255  7
     if (jj_2_29(2147483647)) {
 2256  0
       LocalVariableDeclaration();
 2257  0
       jj_consume_token(SEMICOLON);
 2258   
     } else {
 2259  7
       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
 2260   
       case BOOLEAN:
 2261   
       case BREAK:
 2262   
       case BYTE:
 2263   
       case CHAR:
 2264   
       case CONTINUE:
 2265   
       case DO:
 2266   
       case DOUBLE:
 2267   
       case FALSE:
 2268   
       case FLOAT:
 2269   
       case FOR:
 2270   
       case IF:
 2271   
       case INT:
 2272   
       case LONG:
 2273   
       case NEW:
 2274   
       case NULL:
 2275   
       case RETURN:
 2276   
       case SHORT:
 2277   
       case SUPER:
 2278   
       case SWITCH:
 2279   
       case SYNCHRONIZED:
 2280   
       case THIS:
 2281   
       case THROW:
 2282   
       case TRUE:
 2283   
       case TRY:
 2284   
       case VOID:
 2285   
       case WHILE:
 2286   
       case ASSERT:
 2287   
       case INTEGER_LITERAL:
 2288   
       case FLOATING_POINT_LITERAL:
 2289   
       case CHARACTER_LITERAL:
 2290   
       case STRING_LITERAL:
 2291   
       case IDENTIFIER:
 2292   
       case LPAREN:
 2293   
       case LBRACE:
 2294   
       case SEMICOLON:
 2295   
       case INCR:
 2296   
       case DECR:
 2297  7
         Statement();
 2298  7
         break;
 2299   
       case CLASS:
 2300  0
         UnmodifiedClassDeclaration();
 2301  0
         break;
 2302   
       case INTERFACE:
 2303  0
         UnmodifiedInterfaceDeclaration();
 2304  0
         break;
 2305   
       default:
 2306  0
         jj_la1[92] = jj_gen;
 2307  0
         jj_consume_token(-1);
 2308  0
         throw new ParseException();
 2309   
       }
 2310   
     }
 2311   
   }
 2312   
 
 2313  0
   final public void LocalVariableDeclaration() throws ParseException {
 2314  0
     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
 2315   
     case FINAL:
 2316  0
       jj_consume_token(FINAL);
 2317  0
       break;
 2318   
     default:
 2319  0
       jj_la1[93] = jj_gen;
 2320   
       ;
 2321   
     }
 2322  0
     Type();
 2323  0
     VariableDeclarator();
 2324  0
     label_37:
 2325   
     while (true) {
 2326  0
       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
 2327   
       case COMMA:
 2328   
         ;
 2329  0
         break;
 2330   
       default:
 2331  0
         jj_la1[94] = jj_gen;
 2332  0
         break label_37;
 2333   
       }
 2334  0
       jj_consume_token(COMMA);
 2335  0
       VariableDeclarator();
 2336   
     }
 2337   
   }
 2338   
 
 2339  0
   final public void EmptyStatement() throws ParseException {
 2340  0
     jj_consume_token(SEMICOLON);
 2341   
   }
 2342   
 
 2343  3
   final public void StatementExpression() throws ParseException {
 2344  3
     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
 2345   
     case INCR:
 2346  0
       PreIncrementExpression();
 2347  0
       break;
 2348   
     case DECR:
 2349  0
       PreDecrementExpression();
 2350  0
       break;
 2351   
     case BOOLEAN:
 2352   
     case BYTE:
 2353   
     case CHAR:
 2354   
     case DOUBLE:
 2355   
     case FALSE:
 2356   
     case FLOAT:
 2357   
     case INT:
 2358   
     case LONG:
 2359   
     case NEW:
 2360   
     case NULL:
 2361   
     case SHORT:
 2362   
     case SUPER:
 2363   
     case THIS:
 2364   
     case TRUE:
 2365   
     case VOID:
 2366   
     case INTEGER_LITERAL:
 2367   
     case FLOATING_POINT_LITERAL:
 2368   
     case CHARACTER_LITERAL:
 2369   
     case STRING_LITERAL:
 2370   
     case IDENTIFIER:
 2371   
     case LPAREN:
 2372  3
       PrimaryExpression();
 2373  3
       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
 2374   
       case ASSIGN:
 2375   
       case INCR:
 2376   
       case DECR:
 2377   
       case PLUSASSIGN:
 2378   
       case MINUSASSIGN:
 2379   
       case STARASSIGN:
 2380   
       case SLASHASSIGN:
 2381   
       case ANDASSIGN:
 2382   
       case ORASSIGN:
 2383   
       case XORASSIGN:
 2384   
       case REMASSIGN:
 2385   
       case LSHIFTASSIGN:
 2386   
       case RSIGNEDSHIFTASSIGN:
 2387   
       case RUNSIGNEDSHIFTASSIGN:
 2388  3
         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
 2389   
         case INCR:
 2390  2
           jj_consume_token(INCR);
 2391  2
           break;
 2392   
         case DECR:
 2393  0
           jj_consume_token(DECR);
 2394  0
           break;
 2395   
         case ASSIGN:
 2396   
         case PLUSASSIGN:
 2397   
         case MINUSASSIGN:
 2398   
         case STARASSIGN:
 2399   
         case SLASHASSIGN:
 2400   
         case ANDASSIGN:
 2401   
         case ORASSIGN:
 2402   
         case XORASSIGN:
 2403   
         case REMASSIGN:
 2404   
         case LSHIFTASSIGN:
 2405   
         case RSIGNEDSHIFTASSIGN:
 2406   
         case RUNSIGNEDSHIFTASSIGN:
 2407  1
           AssignmentOperator();
 2408  1
           Expression();
 2409  1
           break;
 2410   
         default:
 2411  0
           jj_la1[95] = jj_gen;
 2412  0
           jj_consume_token(-1);
 2413  0
           throw new ParseException();
 2414   
         }
 2415  3
         break;
 2416   
       default:
 2417  0
         jj_la1[96] = jj_gen;
 2418   
         ;
 2419   
       }
 2420  3
       break;
 2421   
     default:
 2422  0
       jj_la1[97] = jj_gen;
 2423  0
       jj_consume_token(-1);
 2424  0
       throw new ParseException();
 2425   
     }
 2426   
   }
 2427   
 
 2428  0
   final public void SwitchStatement() throws ParseException {
 2429  0
     jj_consume_token(SWITCH);
 2430  0
     jj_consume_token(LPAREN);
 2431  0
     Expression();
 2432  0
     jj_consume_token(RPAREN);
 2433  0
     jj_consume_token(LBRACE);
 2434  0
     label_38:
 2435   
     while (true) {
 2436  0
       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
 2437   
       case CASE:
 2438   
       case _DEFAULT:
 2439   
         ;
 2440  0
         break;
 2441   
       default:
 2442  0
         jj_la1[98] = jj_gen;
 2443  0
         break label_38;
 2444   
       }
 2445  0
       SwitchLabel();
 2446  0
       label_39:
 2447   
       while (true) {
 2448  0
         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
 2449   
         case BOOLEAN:
 2450   
         case BREAK:
 2451   
         case BYTE:
 2452   
         case CHAR:
 2453   
         case CLASS:
 2454   
         case CONTINUE:
 2455   
         case DO:
 2456   
         case DOUBLE:
 2457   
         case FALSE:
 2458   
         case FINAL:
 2459   
         case FLOAT:
 2460   
         case FOR:
 2461   
         case IF:
 2462   
         case INT:
 2463   
         case INTERFACE:
 2464   
         case LONG:
 2465   
         case NEW:
 2466   
         case NULL:
 2467   
         case RETURN:
 2468   
         case SHORT:
 2469   
         case SUPER:
 2470   
         case SWITCH:
 2471   
         case SYNCHRONIZED:
 2472   
         case THIS:
 2473   
         case THROW:
 2474   
         case TRUE:
 2475   
         case TRY:
 2476   
         case VOID:
 2477   
         case WHILE:
 2478   
         case ASSERT:
 2479   
         case INTEGER_LITERAL:
 2480   
         case FLOATING_POINT_LITERAL:
 2481   
         case CHARACTER_LITERAL:
 2482   
         case STRING_LITERAL:
 2483   
         case IDENTIFIER:
 2484   
         case LPAREN:
 2485   
         case LBRACE:
 2486   
         case SEMICOLON:
 2487   
         case INCR:
 2488   
         case DECR:
 2489   
           ;
 2490  0
           break;
 2491   
         default:
 2492  0
           jj_la1[99] = jj_gen;
 2493  0
           break label_39;
 2494   
         }
 2495  0
         BlockStatement();
 2496   
       }
 2497   
     }
 2498  0
     jj_consume_token(RBRACE);
 2499   
   }
 2500   
 
 2501  0
   final public void SwitchLabel() throws ParseException {
 2502  0
     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
 2503   
     case CASE:
 2504  0
       jj_consume_token(CASE);
 2505  0
       Expression();
 2506  0
       jj_consume_token(COLON);
 2507  0
       break;
 2508   
     case _DEFAULT:
 2509  0
       jj_consume_token(_DEFAULT);
 2510  0
       jj_consume_token(COLON);
 2511  0
       break;
 2512   
     default:
 2513  0
       jj_la1[100] = jj_gen;
 2514  0
       jj_consume_token(-1);
 2515  0
       throw new ParseException();
 2516   
     }
 2517   
   }
 2518   
 
 2519  0
   final public void IfStatement() throws ParseException {
 2520  0
     jj_consume_token(IF);
 2521  0
     jj_consume_token(LPAREN);
 2522  0
     Expression();
 2523  0
     jj_consume_token(RPAREN);
 2524  0
     Statement();
 2525  0
     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
 2526   
     case ELSE:
 2527  0
       jj_consume_token(ELSE);
 2528  0
       Statement();
 2529  0
       break;
 2530   
     default:
 2531  0
       jj_la1[101] = jj_gen;
 2532   
       ;
 2533   
     }
 2534   
   }
 2535   
 
 2536  0
   final public void WhileStatement() throws ParseException {
 2537  0
     jj_consume_token(WHILE);
 2538  0
     jj_consume_token(LPAREN);
 2539  0
     Expression();
 2540  0
     jj_consume_token(RPAREN);
 2541  0
     Statement();
 2542   
   }
 2543   
 
 2544  0
   final public void DoStatement() throws ParseException {
 2545  0
     jj_consume_token(DO);
 2546  0
     Statement();
 2547  0
     jj_consume_token(WHILE);
 2548  0
     jj_consume_token(LPAREN);
 2549  0
     Expression();
 2550  0
     jj_consume_token(RPAREN);
 2551  0
     jj_consume_token(SEMICOLON);
 2552   
   }
 2553   
 
 2554  0
   final public void ForStatement() throws ParseException {
 2555  0
     jj_consume_token(FOR);
 2556  0
     jj_consume_token(LPAREN);
 2557  0
     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
 2558   
     case BOOLEAN:
 2559   
     case BYTE:
 2560   
     case CHAR:
 2561   
     case DOUBLE:
 2562   
     case FALSE:
 2563   
     case FINAL:
 2564   
     case FLOAT:
 2565   
     case INT:
 2566   
     case LONG:
 2567   
     case NEW:
 2568   
     case NULL:
 2569   
     case SHORT:
 2570   
     case SUPER:
 2571   
     case THIS:
 2572   
     case TRUE:
 2573   
     case VOID:
 2574   
     case INTEGER_LITERAL:
 2575   
     case FLOATING_POINT_LITERAL:
 2576   
     case CHARACTER_LITERAL:
 2577   
     case STRING_LITERAL:
 2578   
     case IDENTIFIER:
 2579   
     case LPAREN:
 2580   
     case INCR:
 2581   
     case DECR:
 2582  0
       ForInit();
 2583  0
       break;
 2584   
     default:
 2585  0
       jj_la1[102] = jj_gen;
 2586   
       ;
 2587   
     }
 2588  0
     jj_consume_token(SEMICOLON);
 2589  0
     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
 2590   
     case BOOLEAN:
 2591   
     case BYTE:
 2592   
     case CHAR:
 2593   
     case DOUBLE:
 2594   
     case FALSE:
 2595   
     case FLOAT:
 2596   
     case INT:
 2597   
     case LONG:
 2598   
     case NEW:
 2599   
     case NULL:
 2600   
     case SHORT:
 2601   
     case SUPER:
 2602   
     case THIS:
 2603   
     case TRUE:
 2604   
     case VOID:
 2605   
     case INTEGER_LITERAL:
 2606   
     case FLOATING_POINT_LITERAL:
 2607   
     case CHARACTER_LITERAL:
 2608   
     case STRING_LITERAL:
 2609   
     case IDENTIFIER:
 2610   
     case LPAREN:
 2611   
     case BANG:
 2612   
     case TILDE:
 2613   
     case INCR:
 2614   
     case DECR:
 2615   
     case PLUS:
 2616   
     case MINUS:
 2617  0
       Expression();
 2618  0
       break;
 2619   
     default:
 2620  0
       jj_la1[103] = jj_gen;
 2621   
       ;
 2622   
     }
 2623  0
     jj_consume_token(SEMICOLON);
 2624  0
     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
 2625   
     case BOOLEAN:
 2626   
     case BYTE:
 2627   
     case CHAR:
 2628   
     case DOUBLE:
 2629   
     case FALSE:
 2630   
     case FLOAT:
 2631   
     case INT:
 2632   
     case LONG:
 2633   
     case NEW:
 2634   
     case NULL:
 2635   
     case SHORT:
 2636   
     case SUPER:
 2637   
     case THIS:
 2638   
     case TRUE:
 2639   
     case VOID:
 2640   
     case INTEGER_LITERAL:
 2641   
     case FLOATING_POINT_LITERAL:
 2642   
     case CHARACTER_LITERAL:
 2643   
     case STRING_LITERAL:
 2644   
     case IDENTIFIER:
 2645   
     case LPAREN:
 2646   
     case INCR:
 2647   
     case DECR:
 2648  0
       ForUpdate();
 2649  0
       break;
 2650   
     default:
 2651  0
       jj_la1[104] = jj_gen;
 2652   
       ;
 2653   
     }
 2654  0
     jj_consume_token(RPAREN);
 2655  0
     Statement();
 2656   
   }
 2657   
 
 2658  0
   final public void ForInit() throws ParseException {
 2659  0
     if (jj_2_30(2147483647)) {
 2660  0
       LocalVariableDeclaration();
 2661   
     } else {
 2662  0
       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
 2663   
       case BOOLEAN:
 2664   
       case BYTE:
 2665   
       case CHAR:
 2666   
       case DOUBLE:
 2667   
       case FALSE:
 2668   
       case FLOAT:
 2669   
       case INT:
 2670   
       case LONG:
 2671   
       case NEW:
 2672   
       case NULL:
 2673   
       case SHORT:
 2674   
       case SUPER:
 2675   
       case THIS:
 2676   
       case TRUE:
 2677   
       case VOID:
 2678   
       case INTEGER_LITERAL:
 2679   
       case FLOATING_POINT_LITERAL:
 2680   
       case CHARACTER_LITERAL:
 2681   
       case STRING_LITERAL:
 2682   
       case IDENTIFIER:
 2683   
       case LPAREN:
 2684   
       case INCR:
 2685   
       case DECR:
 2686  0
         StatementExpressionList();
 2687  0
         break;
 2688   
       default:
 2689  0
         jj_la1[105] = jj_gen;
 2690  0
         jj_consume_token(-1);
 2691  0
         throw new ParseException();
 2692   
       }
 2693   
     }
 2694   
   }
 2695   
 
 2696  0
   final public void StatementExpressionList() throws ParseException {
 2697  0
     StatementExpression();
 2698  0
     label_40:
 2699   
     while (true) {
 2700  0
       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
 2701   
       case COMMA:
 2702   
         ;
 2703  0
         break;
 2704   
       default:
 2705  0
         jj_la1[106] = jj_gen;
 2706  0
         break label_40;
 2707   
       }
 2708  0
       jj_consume_token(COMMA);
 2709  0
       StatementExpression();
 2710   
     }
 2711   
   }
 2712   
 
 2713  0
   final public void ForUpdate() throws ParseException {
 2714  0
     StatementExpressionList();
 2715   
   }
 2716   
 
 2717  0
   final public void BreakStatement() throws ParseException {
 2718  0
     jj_consume_token(BREAK);
 2719  0
     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
 2720   
     case IDENTIFIER:
 2721  0
       jj_consume_token(IDENTIFIER);
 2722  0
       break;
 2723   
     default:
 2724  0
       jj_la1[107] = jj_gen;
 2725   
       ;
 2726   
     }
 2727  0
     jj_consume_token(SEMICOLON);
 2728   
   }
 2729   
 
 2730  0
   final public void ContinueStatement() throws ParseException {
 2731  0
     jj_consume_token(CONTINUE);
 2732  0
     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
 2733   
     case IDENTIFIER:
 2734  0
       jj_consume_token(IDENTIFIER);
 2735  0
       break;
 2736   
     default:
 2737  0
       jj_la1[108] = jj_gen;
 2738   
       ;
 2739   
     }
 2740  0
     jj_consume_token(SEMICOLON);
 2741   
   }
 2742   
 
 2743  4
   final public void ReturnStatement() throws ParseException {
 2744  4
     jj_consume_token(RETURN);
 2745  4
     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
 2746   
     case BOOLEAN:
 2747   
     case BYTE:
 2748   
     case CHAR:
 2749   
     case DOUBLE:
 2750   
     case FALSE:
 2751   
     case FLOAT:
 2752   
     case INT:
 2753   
     case LONG:
 2754   
     case NEW:
 2755   
     case NULL:
 2756   
     case SHORT:
 2757   
     case SUPER:
 2758   
     case THIS:
 2759   
     case TRUE:
 2760   
     case VOID:
 2761   
     case INTEGER_LITERAL:
 2762   
     case FLOATING_POINT_LITERAL:
 2763   
     case CHARACTER_LITERAL:
 2764   
     case STRING_LITERAL:
 2765   
     case IDENTIFIER:
 2766   
     case LPAREN:
 2767   
     case BANG:
 2768   
     case TILDE:
 2769   
     case INCR:
 2770   
     case DECR:
 2771   
     case PLUS:
 2772   
     case MINUS:
 2773  4
       Expression();
 2774  4
       break;
 2775   
     default:
 2776  0
       jj_la1[109] = jj_gen;
 2777   
       ;
 2778   
     }
 2779  4
     jj_consume_token(SEMICOLON);
 2780   
   }
 2781   
 
 2782  0
   final public void ThrowStatement() throws ParseException {
 2783  0
     jj_consume_token(THROW);
 2784  0
     Expression();
 2785  0
     jj_consume_token(SEMICOLON);
 2786   
   }
 2787   
 
 2788  0
   final public void SynchronizedStatement() throws ParseException {
 2789  0
     jj_consume_token(SYNCHRONIZED);
 2790  0
     jj_consume_token(LPAREN);
 2791  0
     Expression();
 2792  0
     jj_consume_token(RPAREN);
 2793  0
     Block();
 2794   
   }
 2795   
 
 2796  0
   final public void TryStatement() throws ParseException {
 2797  0
     jj_consume_token(TRY);
 2798  0
     Block();
 2799  0
     label_41:
 2800   
     while (true) {
 2801  0
       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
 2802   
       case CATCH:
 2803   
         ;
 2804  0
         break;
 2805   
       default:
 2806  0
         jj_la1[110] = jj_gen;
 2807  0
         break label_41;
 2808   
       }
 2809  0
       jj_consume_token(CATCH);
 2810  0
       jj_consume_token(LPAREN);
 2811  0
       FormalParameter();
 2812  0
       jj_consume_token(RPAREN);
 2813  0
       Block();
 2814   
     }
 2815  0
     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
 2816   
     case FINALLY:
 2817  0
       jj_consume_token(FINALLY);
 2818  0
       Block();
 2819  0
       break;
 2820   
     default:
 2821  0
       jj_la1[111] = jj_gen;
 2822   
       ;
 2823   
     }
 2824   
   }
 2825   
 
 2826   
 // added by Andrea Gini
 2827  0
   final public void AssertStatement() throws ParseException {
 2828  0
     jj_consume_token(ASSERT);
 2829  0
     Expression();
 2830  0
     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
 2831   
     case COLON:
 2832  0
       jj_consume_token(COLON);
 2833  0
       Expression();
 2834  0
       break;
 2835   
     default:
 2836  0
       jj_la1[112] = jj_gen;
 2837   
       ;
 2838   
     }
 2839  0
     jj_consume_token(SEMICOLON);
 2840   
   }
 2841   
 
 2842  8
   final private boolean jj_2_1(int xla) {
 2843  8
     jj_la = xla; jj_lastpos = jj_scanpos = token;
 2844  8
     boolean retval = !jj_3_1();
 2845  8
     jj_save(0, xla);
 2846  8
     return retval;
 2847   
   }
 2848   
 
 2849  9
   final private boolean jj_2_2(int xla) {
 2850  9
     jj_la = xla; jj_lastpos = jj_scanpos = token;
 2851  9
     boolean retval = !jj_3_2();
 2852  9
     jj_save(1, xla);
 2853  9
     return retval;
 2854   
   }
 2855   
 
 2856  9
   final private boolean jj_2_3(int xla) {
 2857  9
     jj_la = xla; jj_lastpos = jj_scanpos = token;
 2858  9
     boolean retval = !jj_3_3();
 2859  9
     jj_save(2, xla);
 2860  9
     return retval;
 2861   
   }
 2862   
 
 2863  9
   final private boolean jj_2_4(int xla) {
 2864  9
     jj_la = xla; jj_lastpos = jj_scanpos = token;
 2865  9
     boolean retval = !jj_3_4();
 2866  9
     jj_save(3, xla);
 2867  9
     return retval;
 2868   
   }
 2869   
 
 2870  9
   final private boolean jj_2_5(int xla) {
 2871  9
     jj_la = xla; jj_lastpos = jj_scanpos = token;
 2872  9
     boolean retval = !jj_3_5();
 2873  9
     jj_save(4, xla);
 2874  9
     return retval;
 2875   
   }
 2876   
 
 2877  9
   final private boolean jj_2_6(int xla) {
 2878  9
     jj_la = xla; jj_lastpos = jj_scanpos = token;
 2879  9
     boolean retval = !jj_3_6();
 2880  9
     jj_save(5, xla);
 2881  9
     return retval;
 2882   
   }
 2883   
 
 2884  3
   final private boolean jj_2_7(int xla) {
 2885  3
     jj_la = xla; jj_lastpos = jj_scanpos = token;
 2886  3
     boolean retval = !jj_3_7();
 2887  3
     jj_save(6, xla);
 2888  3
     return retval;
 2889   
   }
 2890   
 
 2891  3
   final private boolean jj_2_8(int xla) {
 2892  3
     jj_la = xla; jj_lastpos = jj_scanpos = token;
 2893  3
     boolean retval = !jj_3_8();
 2894  3
     jj_save(7, xla);
 2895  3
     return retval;
 2896   
   }
 2897   
 
 2898  3
   final private boolean jj_2_9(int xla) {
 2899  3
     jj_la = xla; jj_lastpos = jj_scanpos = token;
 2900  3
     boolean retval = !jj_3_9();
 2901  3
     jj_save(8, xla);
 2902  3
     return retval;
 2903   
   }
 2904   
 
 2905  0
   final private boolean jj_2_10(int xla) {
 2906  0
     jj_la = xla; jj_lastpos = jj_scanpos = token;
 2907  0
     boolean retval = !jj_3_10();
 2908  0
     jj_save(9, xla);
 2909  0
     return retval;
 2910   
   }
 2911   
 
 2912  0
   final private boolean jj_2_11(int xla) {
 2913  0
     jj_la = xla; jj_lastpos = jj_scanpos = token;
 2914  0
     boolean retval = !jj_3_11();
 2915  0
     jj_save(10, xla);
 2916  0
     return retval;
 2917   
   }
 2918   
 
 2919  0
   final private boolean jj_2_12(int xla) {
 2920  0
     jj_la = xla; jj_lastpos = jj_scanpos = token;
 2921  0
     boolean retval = !jj_3_12();
 2922  0
     jj_save(11, xla);
 2923  0
     return retval;
 2924   
   }
 2925   
 
 2926  0
   final private boolean jj_2_13(int xla) {
 2927  0
     jj_la = xla; jj_lastpos = jj_scanpos = token;
 2928  0
     boolean retval = !jj_3_13();
 2929  0
     jj_save(12, xla);
 2930  0
     return retval;
 2931   
   }
 2932   
 
 2933  49
   final private boolean jj_2_14(int xla) {
 2934  49
     jj_la = xla; jj_lastpos = jj_scanpos = token;
 2935  49
     boolean retval = !jj_3_14();
 2936  49
     jj_save(13, xla);
 2937  49
     return retval;
 2938   
   }
 2939   
 
 2940  8
   final private boolean jj_2_15(int xla) {
 2941  8
     jj_la = xla; jj_lastpos = jj_scanpos = token;
 2942  8
     boolean retval = !jj_3_15();
 2943  8
     jj_save(14, xla);
 2944  8
     return retval;
 2945   
   }
 2946   
 
 2947  0
   final private boolean jj_2_16(int xla) {
 2948  0
     jj_la = xla; jj_lastpos = jj_scanpos = token;
 2949  0
     boolean retval = !jj_3_16();
 2950  0
     jj_save(15, xla);
 2951  0
     return retval;
 2952   
   }
 2953   
 
 2954  0
   final private boolean jj_2_17(int xla) {
 2955  0
     jj_la = xla; jj_lastpos = jj_scanpos = token;
 2956  0
     boolean retval = !jj_3_17();
 2957  0
     jj_save(16, xla);
 2958  0
     return retval;
 2959   
   }
 2960   
 
 2961  0
   final private boolean jj_2_18(int xla) {
 2962  0
     jj_la = xla; jj_lastpos = jj_scanpos = token;
 2963  0
     boolean retval = !jj_3_18();
 2964  0
     jj_save(17, xla);
 2965  0
     return retval;
 2966   
   }
 2967   
 
 2968  14
   final private boolean jj_2_19(int xla) {
 2969  14
     jj_la = xla; jj_lastpos = jj_scanpos = token;
 2970  14
     boolean retval = !jj_3_19();
 2971  14
     jj_save(18, xla);
 2972  14
     return retval;
 2973   
   }
 2974   
 
 2975  7
   final private boolean jj_2_20(int xla) {
 2976  7
     jj_la = xla; jj_lastpos = jj_scanpos = token;
 2977  7
     boolean retval = !jj_3_20();
 2978  7
     jj_save(19, xla);
 2979  7
     return retval;
 2980   
   }
 2981   
 
 2982  3
   final private boolean jj_2_21(int xla) {
 2983  3
     jj_la = xla; jj_lastpos = jj_scanpos = token;
 2984  3
     boolean retval = !jj_3_21();
 2985  3
     jj_save(20, xla);
 2986  3
     return retval;
 2987   
   }
 2988   
 
 2989  3
   final private boolean jj_2_22(int xla) {
 2990  3
     jj_la = xla; jj_lastpos = jj_scanpos = token;
 2991  3
     boolean retval = !jj_3_22();
 2992  3
     jj_save(21, xla);
 2993  3
     return retval;
 2994   
   }
 2995   
 
 2996  3
   final private boolean jj_2_23(int xla) {
 2997  3
     jj_la = xla; jj_lastpos = jj_scanpos = token;
 2998  3
     boolean retval = !jj_3_23();
 2999  3
     jj_save(22, xla);
 3000  3
     return retval;
 3001   
   }
 3002   
 
 3003  0
   final private boolean jj_2_24(int xla) {
 3004  0
     jj_la = xla; jj_lastpos = jj_scanpos = token;
 3005  0
     boolean retval = !jj_3_24();
 3006  0
     jj_save(23, xla);
 3007  0
     return retval;