net.sourceforge.phpeclipse/src/test/PHPParser.java

   1 /* Generated By:JavaCC: Do not edit this line. PHPParser.java */
   2 package test;
   3
   4 import org.eclipse.core.resources.IFile;
   5 import org.eclipse.core.resources.IMarker;
   6 import org.eclipse.core.runtime.CoreException;
   7 import org.eclipse.ui.texteditor.MarkerUtilities;
   8 import org.eclipse.jface.preference.IPreferenceStore;
   9
  10 import java.util.Hashtable;
  11 import java.io.StringReader;
  12 import java.text.MessageFormat;
  13
  14 import net.sourceforge.phpeclipse.actions.PHPStartApacheAction;
  15 import net.sourceforge.phpeclipse.PHPeclipsePlugin;
  16 import net.sourceforge.phpdt.internal.compiler.parser.PHPOutlineInfo;
  17 import net.sourceforge.phpdt.internal.compiler.parser.PHPSegmentWithChildren;
  18 import net.sourceforge.phpdt.internal.compiler.parser.PHPFunctionDeclaration;
  19 import net.sourceforge.phpdt.internal.compiler.parser.PHPClassDeclaration;
  20
  21 /**
  22  * A new php parser.
  23  * This php parser is inspired by the Java 1.2 grammar example
  24  * given with JavaCC. You can get JavaCC at http://www.webgain.com
  25  * You can test the parser with the PHPParserTestCase2.java
  26  * @author Matthieu Casanova
  27  */
  28 public class PHPParser extends PHPParserSuperclass implements PHPParserConstants {
  29
  30   private static IFile fileToParse;
  31
  32   /** The current segment */
  33   private static PHPSegmentWithChildren currentSegment;
  34
  35   private static final String PARSE_ERROR_STRING = "Parse error"; //$NON-NLS-1$
  36   private static final String PARSE_WARNING_STRING = "Warning"; //$NON-NLS-1$
  37   public static final int ERROR = 2;
  38   public static final int WARNING = 1;
  39   public static final int INFO = 0;
  40   PHPOutlineInfo outlineInfo;
  41   private static int errorLevel = ERROR;
  42   private static String errorMessage;
  43
  44   public PHPParser() {
  45   }
  46
  47   public void setFileToParse(IFile fileToParse) {
  48     this.fileToParse = fileToParse;
  49   }
  50
  51   public PHPParser(IFile fileToParse) {
  52     this(new StringReader(""));
  53     this.fileToParse = fileToParse;
  54   }
  55
  56   public void phpParserTester(String strEval) throws CoreException, ParseException {
  57     PHPParserTokenManager.SwitchTo(PHPParserTokenManager.PHPPARSING);
  58     StringReader stream = new StringReader(strEval);
  59     if (jj_input_stream == null) {
  60       jj_input_stream = new SimpleCharStream(stream, 1, 1);
  61     }
  62     ReInit(new StringReader(strEval));
  63     phpTest();
  64   }
  65
  66   public void htmlParserTester(String strEval) throws CoreException, ParseException {
  67     StringReader stream = new StringReader(strEval);
  68     if (jj_input_stream == null) {
  69       jj_input_stream = new SimpleCharStream(stream, 1, 1);
  70     }
  71     ReInit(stream);
  72     phpFile();
  73   }
  74
  75   public PHPOutlineInfo parseInfo(Object parent, String s) {
  76     outlineInfo = new PHPOutlineInfo(parent);
  77     currentSegment = outlineInfo.getDeclarations();
  78     StringReader stream = new StringReader(s);
  79     if (jj_input_stream == null) {
  80       jj_input_stream = new SimpleCharStream(stream, 1, 1);
  81     }
  82     ReInit(stream);
  83     try {
  84       parse();
  85     } catch (ParseException e) {
  86       if (errorMessage == null) {
  87         PHPeclipsePlugin.log(e);
  88       } else {
  89         setMarker(errorMessage, e.currentToken.beginLine, errorLevel);
  90         errorMessage = null;
  91       }
  92     }
  93     return outlineInfo;
  94   }
  95
  96
  97   /**
  98    * Create marker for the parse error
  99    */
 100   private static void setMarker(String message, int lineNumber, int errorLevel) {
 101     try {
 102       setMarker(fileToParse, message, lineNumber, errorLevel);
 103     } catch (CoreException e) {
 104       PHPeclipsePlugin.log(e);
 105     }
 106   }
 107
 108   public static void setMarker(IFile file, String message, int lineNumber, int errorLevel) throws CoreException {
 109     if (file != null) {
 110       Hashtable attributes = new Hashtable();
 111       MarkerUtilities.setMessage(attributes, message);
 112       switch (errorLevel) {
 113         case ERROR :
 114           attributes.put(IMarker.SEVERITY, new Integer(IMarker.SEVERITY_ERROR));
 115           break;
 116         case WARNING :
 117           attributes.put(IMarker.SEVERITY, new Integer(IMarker.SEVERITY_WARNING));
 118           break;
 119         case INFO :
 120           attributes.put(IMarker.SEVERITY, new Integer(IMarker.SEVERITY_INFO));
 121           break;
 122       }
 123       MarkerUtilities.setLineNumber(attributes, lineNumber);
 124       MarkerUtilities.createMarker(file, attributes, IMarker.PROBLEM);
 125     }
 126   }
 127
 128   /**
 129    * Create markers according to the external parser output
 130    */
 131   private static void createMarkers(String output, IFile file) throws CoreException {
 132     // delete all markers
 133     file.deleteMarkers(IMarker.PROBLEM, false, 0);
 134
 135     int indx = 0;
 136     int brIndx = 0;
 137     boolean flag = true;
 138     while ((brIndx = output.indexOf("<br />", indx)) != -1) {
 139       // newer php error output (tested with 4.2.3)
 140       scanLine(output, file, indx, brIndx);
 141       indx = brIndx + 6;
 142       flag = false;
 143     }
 144     if (flag) {
 145       while ((brIndx = output.indexOf("<br>", indx)) != -1) {
 146         // older php error output (tested with 4.2.3)
 147         scanLine(output, file, indx, brIndx);
 148         indx = brIndx + 4;
 149       }
 150     }
 151   }
 152
 153   private static void scanLine(String output, IFile file, int indx, int brIndx) throws CoreException {
 154     String current;
 155     StringBuffer lineNumberBuffer = new StringBuffer(10);
 156     char ch;
 157     current = output.substring(indx, brIndx);
 158
 159     if (current.indexOf(PARSE_WARNING_STRING) != -1 || current.indexOf(PARSE_ERROR_STRING) != -1) {
 160       int onLine = current.indexOf("on line <b>");
 161       if (onLine != -1) {
 162         lineNumberBuffer.delete(0, lineNumberBuffer.length());
 163         for (int i = onLine; i < current.length(); i++) {
 164           ch = current.charAt(i);
 165           if ('0' <= ch && '9' >= ch) {
 166             lineNumberBuffer.append(ch);
 167           }
 168         }
 169
 170         int lineNumber = Integer.parseInt(lineNumberBuffer.toString());
 171
 172         Hashtable attributes = new Hashtable();
 173
 174         current = current.replaceAll("\n", "");
 175         current = current.replaceAll("<b>", "");
 176         current = current.replaceAll("</b>", "");
 177         MarkerUtilities.setMessage(attributes, current);
 178
 179         if (current.indexOf(PARSE_ERROR_STRING) != -1)
 180           attributes.put(IMarker.SEVERITY, new Integer(IMarker.SEVERITY_ERROR));
 181         else if (current.indexOf(PARSE_WARNING_STRING) != -1)
 182           attributes.put(IMarker.SEVERITY, new Integer(IMarker.SEVERITY_WARNING));
 183         else
 184           attributes.put(IMarker.SEVERITY, new Integer(IMarker.SEVERITY_INFO));
 185         MarkerUtilities.setLineNumber(attributes, lineNumber);
 186         MarkerUtilities.createMarker(file, attributes, IMarker.PROBLEM);
 187       }
 188     }
 189   }
 190
 191   public void parse(String s) throws CoreException {
 192     ReInit(new StringReader(s));
 193     try {
 194       parse();
 195     } catch (ParseException e) {
 196       if (errorMessage == null) {
 197         PHPeclipsePlugin.log(e);
 198       } else {
 199         setMarker(errorMessage, e.currentToken.beginLine, errorLevel);
 200         errorMessage = null;
 201       }
 202     }
 203   }
 204
 205   /**
 206    * Call the php parse command ( php -l -f &lt;filename&gt; )
 207    * and create markers according to the external parser output
 208    */
 209   public static void phpExternalParse(IFile file) {
 210     IPreferenceStore store = PHPeclipsePlugin.getDefault().getPreferenceStore();
 211     String filename = file.getLocation().toString();
 212
 213     String[] arguments = { filename };
 214     MessageFormat form = new MessageFormat(store.getString(PHPeclipsePlugin.EXTERNAL_PARSER_PREF));
 215     String command = form.format(arguments);
 216
 217     String parserResult = PHPStartApacheAction.getParserOutput(command, "External parser: ");
 218
 219     try {
 220       // parse the buffer to find the errors and warnings
 221       createMarkers(parserResult, file);
 222     } catch (CoreException e) {
 223       PHPeclipsePlugin.log(e);
 224     }
 225   }
 226
 227   public void parse() throws ParseException {
 228           phpFile();
 229   }
 230
 231 /*****************************************
 232  * THE JAVA LANGUAGE GRAMMAR STARTS HERE *
 233  *****************************************/
 234
 235 /*
 236  * Program structuring syntax follows.
 237  */
 238   static final public void phpTest() throws ParseException {
 239     Php();
 240     jj_consume_token(0);
 241   }
 242
 243   static final public void phpFile() throws ParseException {
 244     label_1:
 245     while (true) {
 246       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
 247       case PHPSTART:
 248         ;
 249         break;
 250       default:
 251         jj_la1[0] = jj_gen;
 252         break label_1;
 253       }
 254       jj_consume_token(PHPSTART);
 255       Php();
 256       jj_consume_token(PHPEND);
 257     }
 258     jj_consume_token(0);
 259   }
 260
 261   static final public void Php() throws ParseException {
 262     label_2:
 263     while (true) {
 264       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
 265       case CLASS:
 266       case FUNCTION:
 267       case IF:
 268       case ARRAY:
 269       case PRINT:
 270       case ECHO:
 271       case INCLUDE:
 272       case REQUIRE:
 273       case INCLUDE_ONCE:
 274       case REQUIRE_ONCE:
 275       case GLOBAL:
 276       case STATIC:
 277       case BREAK:
 278       case CONTINUE:
 279       case DO:
 280       case FALSE:
 281       case FOR:
 282       case NEW:
 283       case NULL:
 284       case RETURN:
 285       case SWITCH:
 286       case TRUE:
 287       case WHILE:
 288       case INTEGER_LITERAL:
 289       case FLOATING_POINT_LITERAL:
 290       case STRING_LITERAL:
 291       case IDENTIFIER:
 292       case LPAREN:
 293       case LBRACE:
 294       case SEMICOLON:
 295       case AT:
 296       case DOLLAR:
 297       case BANG:
 298       case INCR:
 299       case DECR:
 300       case PLUS:
 301       case MINUS:
 302       case BIT_AND:
 303       case DOLLAR_ID:
 304         ;
 305         break;
 306       default:
 307         jj_la1[1] = jj_gen;
 308         break label_2;
 309       }
 310       BlockStatement();
 311     }
 312   }
 313
 314   static final public void ClassDeclaration() throws ParseException {
 315   PHPClassDeclaration classDeclaration;
 316   Token className;
 317   int pos = jj_input_stream.bufpos;
 318     jj_consume_token(CLASS);
 319     className = jj_consume_token(IDENTIFIER);
 320     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
 321     case EXTENDS:
 322       jj_consume_token(EXTENDS);
 323       jj_consume_token(IDENTIFIER);
 324       break;
 325     default:
 326       jj_la1[2] = jj_gen;
 327       ;
 328     }
 329     classDeclaration = new PHPClassDeclaration(currentSegment,className.image,pos);
 330     currentSegment.add(classDeclaration);
 331     currentSegment = classDeclaration;
 332     ClassBody();
 333     currentSegment = (PHPSegmentWithChildren) currentSegment.getParent();
 334   }
 335
 336   static final public void ClassBody() throws ParseException {
 337     jj_consume_token(LBRACE);
 338     label_3:
 339     while (true) {
 340       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
 341       case FUNCTION:
 342       case VAR:
 343         ;
 344         break;
 345       default:
 346         jj_la1[3] = jj_gen;
 347         break label_3;
 348       }
 349       ClassBodyDeclaration();
 350     }
 351     jj_consume_token(RBRACE);
 352   }
 353
 354   static final public void ClassBodyDeclaration() throws ParseException {
 355     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
 356     case FUNCTION:
 357       MethodDeclaration();
 358       break;
 359     case VAR:
 360       FieldDeclaration();
 361       break;
 362     default:
 363       jj_la1[4] = jj_gen;
 364       jj_consume_token(-1);
 365       throw new ParseException();
 366     }
 367   }
 368
 369   static final public void FieldDeclaration() throws ParseException {
 370     jj_consume_token(VAR);
 371     VariableDeclarator();
 372     label_4:
 373     while (true) {
 374       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
 375       case COMMA:
 376         ;
 377         break;
 378       default:
 379         jj_la1[5] = jj_gen;
 380         break label_4;
 381       }
 382       jj_consume_token(COMMA);
 383       VariableDeclarator();
 384     }
 385     jj_consume_token(SEMICOLON);
 386   }
 387
 388   static final public String VariableDeclarator() throws ParseException {
 389   String expr;
 390   StringBuffer buff = new StringBuffer();
 391     expr = VariableDeclaratorId();
 392    buff.append(expr);
 393     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
 394     case ASSIGN:
 395       jj_consume_token(ASSIGN);
 396       expr = VariableInitializer();
 397      buff.append("=").append(expr);
 398       break;
 399     default:
 400       jj_la1[6] = jj_gen;
 401       ;
 402     }
 403    {if (true) return buff.toString();}
 404     throw new Error("Missing return statement in function");
 405   }
 406
 407   static final public String VariableDeclaratorId() throws ParseException {
 408   String expr;
 409   StringBuffer buff = new StringBuffer();
 410     expr = Variable();
 411    buff.append(expr);
 412     label_5:
 413     while (true) {
 414       if (jj_2_1(2)) {
 415         ;
 416       } else {
 417         break label_5;
 418       }
 419       expr = VariableSuffix();
 420    buff.append(expr);
 421     }
 422    {if (true) return buff.toString();}
 423     throw new Error("Missing return statement in function");
 424   }
 425
 426   static final public String Variable() throws ParseException {
 427   String expr = null;
 428   Token token;
 429     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
 430     case DOLLAR_ID:
 431       token = jj_consume_token(DOLLAR_ID);
 432       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
 433       case LBRACE:
 434         jj_consume_token(LBRACE);
 435         expr = Expression();
 436         jj_consume_token(RBRACE);
 437         break;
 438       default:
 439         jj_la1[7] = jj_gen;
 440         ;
 441       }
 442     if (expr == null) {
 443       {if (true) return token.image;}
 444     }
 445     {if (true) return token + "{" + expr + "}";}
 446       break;
 447     case DOLLAR:
 448       jj_consume_token(DOLLAR);
 449       expr = VariableName();
 450    {if (true) return "$" + expr;}
 451       break;
 452     default:
 453       jj_la1[8] = jj_gen;
 454       jj_consume_token(-1);
 455       throw new ParseException();
 456     }
 457     throw new Error("Missing return statement in function");
 458   }
 459
 460   static final public String VariableName() throws ParseException {
 461 String expr = null;
 462 Token token;
 463     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
 464     case LBRACE:
 465       jj_consume_token(LBRACE);
 466       expr = Expression();
 467       jj_consume_token(RBRACE);
 468    {if (true) return "{"+expr+"}";}
 469       break;
 470     case IDENTIFIER:
 471       token = jj_consume_token(IDENTIFIER);
 472       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
 473       case LBRACE:
 474         jj_consume_token(LBRACE);
 475         expr = Expression();
 476         jj_consume_token(RBRACE);
 477         break;
 478       default:
 479         jj_la1[9] = jj_gen;
 480         ;
 481       }
 482     if (expr == null) {
 483       {if (true) return token.image;}
 484     }
 485     {if (true) return token + "{" + expr + "}";}
 486       break;
 487     case DOLLAR:
 488       jj_consume_token(DOLLAR);
 489       expr = VariableName();
 490    {if (true) return "$" + expr;}
 491       break;
 492     default:
 493       jj_la1[10] = jj_gen;
 494       jj_consume_token(-1);
 495       throw new ParseException();
 496     }
 497     throw new Error("Missing return statement in function");
 498   }
 499
 500   static final public String VariableInitializer() throws ParseException {
 501   String expr;
 502     expr = Expression();
 503    {if (true) return expr;}
 504     throw new Error("Missing return statement in function");
 505   }
 506
 507   static final public String ArrayVariable() throws ParseException {
 508 String expr;
 509 StringBuffer buff = new StringBuffer();
 510     expr = Expression();
 511    buff.append(expr);
 512     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
 513     case ARRAYASSIGN:
 514       jj_consume_token(ARRAYASSIGN);
 515       expr = Expression();
 516     buff.append("=>").append(expr);
 517       break;
 518     default:
 519       jj_la1[11] = jj_gen;
 520       ;
 521     }
 522    {if (true) return buff.toString();}
 523     throw new Error("Missing return statement in function");
 524   }
 525
 526   static final public String ArrayInitializer() throws ParseException {
 527 String expr = null;
 528 StringBuffer buff = new StringBuffer("(");
 529     jj_consume_token(LPAREN);
 530     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
 531     case ARRAY:
 532     case PRINT:
 533     case FALSE:
 534     case NEW:
 535     case NULL:
 536     case TRUE:
 537     case INTEGER_LITERAL:
 538     case FLOATING_POINT_LITERAL:
 539     case STRING_LITERAL:
 540     case IDENTIFIER:
 541     case LPAREN:
 542     case AT:
 543     case DOLLAR:
 544     case BANG:
 545     case INCR:
 546     case DECR:
 547     case PLUS:
 548     case MINUS:
 549     case BIT_AND:
 550     case DOLLAR_ID:
 551       expr = ArrayVariable();
 552              buff.append(expr);
 553       label_6:
 554       while (true) {
 555         if (jj_2_2(2)) {
 556           ;
 557         } else {
 558           break label_6;
 559         }
 560         jj_consume_token(COMMA);
 561         expr = ArrayVariable();
 562              buff.append(",").append(expr);
 563       }
 564       break;
 565     default:
 566       jj_la1[12] = jj_gen;
 567       ;
 568     }
 569     jj_consume_token(RPAREN);
 570     buff.append(")");
 571     {if (true) return buff.toString();}
 572     throw new Error("Missing return statement in function");
 573   }
 574
 575   static final public void MethodDeclaration() throws ParseException {
 576   PHPFunctionDeclaration functionDeclaration;
 577     jj_consume_token(FUNCTION);
 578     functionDeclaration = MethodDeclarator();
 579     currentSegment.add(functionDeclaration);
 580     currentSegment = functionDeclaration;
 581     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
 582     case LBRACE:
 583       Block();
 584       break;
 585     case SEMICOLON:
 586       jj_consume_token(SEMICOLON);
 587       break;
 588     default:
 589       jj_la1[13] = jj_gen;
 590       jj_consume_token(-1);
 591       throw new ParseException();
 592     }
 593     currentSegment = (PHPSegmentWithChildren) currentSegment.getParent();
 594   }
 595
 596   static final public PHPFunctionDeclaration MethodDeclarator() throws ParseException {
 597   Token identifier;
 598   StringBuffer methodDeclaration = new StringBuffer();
 599   String formalParameters;
 600   int pos = jj_input_stream.bufpos;
 601     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
 602     case BIT_AND:
 603       jj_consume_token(BIT_AND);
 604                methodDeclaration.append("&");
 605       break;
 606     default:
 607       jj_la1[14] = jj_gen;
 608       ;
 609     }
 610     identifier = jj_consume_token(IDENTIFIER);
 611     formalParameters = FormalParameters();
 612     methodDeclaration.append(identifier).append(formalParameters);
 613     {if (true) return new PHPFunctionDeclaration(currentSegment,methodDeclaration.toString(),pos);}
 614     throw new Error("Missing return statement in function");
 615   }
 616
 617   static final public String FormalParameters() throws ParseException {
 618   String expr;
 619   StringBuffer buff = new StringBuffer("(");
 620     jj_consume_token(LPAREN);
 621     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
 622     case DOLLAR:
 623     case BIT_AND:
 624     case DOLLAR_ID:
 625       expr = FormalParameter();
 626                                        buff.append(expr);
 627       label_7:
 628       while (true) {
 629         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
 630         case COMMA:
 631           ;
 632           break;
 633         default:
 634           jj_la1[15] = jj_gen;
 635           break label_7;
 636         }
 637         jj_consume_token(COMMA);
 638         expr = FormalParameter();
 639              buff.append(",").append(expr);
 640       }
 641       break;
 642     default:
 643       jj_la1[16] = jj_gen;
 644       ;
 645     }
 646     jj_consume_token(RPAREN);
 647   buff.append(")");
 648   {if (true) return buff.toString();}
 649     throw new Error("Missing return statement in function");
 650   }
 651
 652   static final public String FormalParameter() throws ParseException {
 653   String expr;
 654   StringBuffer buff = new StringBuffer();
 655     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
 656     case BIT_AND:
 657       jj_consume_token(BIT_AND);
 658               buff.append("&");
 659       break;
 660     default:
 661       jj_la1[17] = jj_gen;
 662       ;
 663     }
 664     expr = VariableDeclarator();
 665     buff.append(expr);
 666     {if (true) return buff.toString();}
 667     throw new Error("Missing return statement in function");
 668   }
 669
 670   static final public String Type() throws ParseException {
 671     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
 672     case STRING:
 673       jj_consume_token(STRING);
 674    {if (true) return "string";}
 675       break;
 676     case BOOL:
 677       jj_consume_token(BOOL);
 678    {if (true) return "bool";}
 679       break;
 680     case BOOLEAN:
 681       jj_consume_token(BOOLEAN);
 682    {if (true) return "boolean";}
 683       break;
 684     case REAL:
 685       jj_consume_token(REAL);
 686    {if (true) return "real";}
 687       break;
 688     case DOUBLE:
 689       jj_consume_token(DOUBLE);
 690    {if (true) return "double";}
 691       break;
 692     case FLOAT:
 693       jj_consume_token(FLOAT);
 694    {if (true) return "float";}
 695       break;
 696     case INT:
 697       jj_consume_token(INT);
 698    {if (true) return "int";}
 699       break;
 700     case INTEGER:
 701       jj_consume_token(INTEGER);
 702    {if (true) return "integer";}
 703       break;
 704     default:
 705       jj_la1[18] = jj_gen;
 706       jj_consume_token(-1);
 707       throw new ParseException();
 708     }
 709     throw new Error("Missing return statement in function");
 710   }
 711
 712   static final public String Expression() throws ParseException {
 713   String expr;
 714   String assignOperator = null;
 715   String expr2 = null;
 716     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
 717     case PRINT:
 718       expr = PrintExpression();
 719    {if (true) return expr;}
 720       break;
 721     case ARRAY:
 722     case FALSE:
 723     case NEW:
 724     case NULL:
 725     case TRUE:
 726     case INTEGER_LITERAL:
 727     case FLOATING_POINT_LITERAL:
 728     case STRING_LITERAL:
 729     case IDENTIFIER:
 730     case LPAREN:
 731     case AT:
 732     case DOLLAR:
 733     case BANG:
 734     case INCR:
 735     case DECR:
 736     case PLUS:
 737     case MINUS:
 738     case BIT_AND:
 739     case DOLLAR_ID:
 740       expr = ConditionalExpression();
 741       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
 742       case ASSIGN:
 743       case PLUSASSIGN:
 744       case MINUSASSIGN:
 745       case STARASSIGN:
 746       case SLASHASSIGN:
 747       case ANDASSIGN:
 748       case ORASSIGN:
 749       case XORASSIGN:
 750       case DOTASSIGN:
 751       case REMASSIGN:
 752       case LSHIFTASSIGN:
 753       case RSIGNEDSHIFTASSIGN:
 754       case RUNSIGNEDSHIFTASSIGN:
 755         assignOperator = AssignmentOperator();
 756         expr2 = Expression();
 757         break;
 758       default:
 759         jj_la1[19] = jj_gen;
 760         ;
 761       }
 762     if (expr2 == null) {
 763       {if (true) return expr;}
 764     } else {
 765       {if (true) return expr + assignOperator + expr2;}
 766     }
 767       break;
 768     default:
 769       jj_la1[20] = jj_gen;
 770       jj_consume_token(-1);
 771       throw new ParseException();
 772     }
 773     throw new Error("Missing return statement in function");
 774   }
 775
 776   static final public String AssignmentOperator() throws ParseException {
 777   Token assignOperator;
 778     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
 779     case ASSIGN:
 780       jj_consume_token(ASSIGN);
 781  {if (true) return "=";}
 782       break;
 783     case STARASSIGN:
 784       jj_consume_token(STARASSIGN);
 785  {if (true) return "*=";}
 786       break;
 787     case SLASHASSIGN:
 788       jj_consume_token(SLASHASSIGN);
 789  {if (true) return "/=";}
 790       break;
 791     case REMASSIGN:
 792       jj_consume_token(REMASSIGN);
 793  {if (true) return "%=";}
 794       break;
 795     case PLUSASSIGN:
 796       jj_consume_token(PLUSASSIGN);
 797  {if (true) return "+=";}
 798       break;
 799     case MINUSASSIGN:
 800       jj_consume_token(MINUSASSIGN);
 801  {if (true) return "-=";}
 802       break;
 803     case LSHIFTASSIGN:
 804       jj_consume_token(LSHIFTASSIGN);
 805  {if (true) return "<<=";}
 806       break;
 807     case RSIGNEDSHIFTASSIGN:
 808       jj_consume_token(RSIGNEDSHIFTASSIGN);
 809  {if (true) return ">>=";}
 810       break;
 811     case RUNSIGNEDSHIFTASSIGN:
 812       jj_consume_token(RUNSIGNEDSHIFTASSIGN);
 813  {if (true) return ">>>=";}
 814       break;
 815     case ANDASSIGN:
 816       jj_consume_token(ANDASSIGN);
 817  {if (true) return "&=";}
 818       break;
 819     case XORASSIGN:
 820       jj_consume_token(XORASSIGN);
 821  {if (true) return "|=";}
 822       break;
 823     case ORASSIGN:
 824       jj_consume_token(ORASSIGN);
 825  {if (true) return "|=";}
 826       break;
 827     case DOTASSIGN:
 828       jj_consume_token(DOTASSIGN);
 829  {if (true) return ".=";}
 830       break;
 831     default:
 832       jj_la1[21] = jj_gen;
 833       jj_consume_token(-1);
 834       throw new ParseException();
 835     }
 836     throw new Error("Missing return statement in function");
 837   }
 838
 839   static final public String ConditionalExpression() throws ParseException {
 840   String expr;
 841   String expr2 = null;
 842   String expr3 = null;
 843     expr = ConditionalOrExpression();
 844     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
 845     case HOOK:
 846       jj_consume_token(HOOK);
 847       expr2 = Expression();
 848       jj_consume_token(COLON);
 849       expr3 = ConditionalExpression();
 850       break;
 851     default:
 852       jj_la1[22] = jj_gen;
 853       ;
 854     }
 855   if (expr3 == null) {
 856     {if (true) return expr;}
 857   } else {
 858     {if (true) return expr + "?" + expr2 + ":" + expr3;}
 859   }
 860     throw new Error("Missing return statement in function");
 861   }
 862
 863   static final public String ConditionalOrExpression() throws ParseException {
 864   String expr;
 865   Token operator;
 866   String expr2 = null;
 867   StringBuffer buff = new StringBuffer();
 868     expr = ConditionalAndExpression();
 869     buff.append(expr);
 870     label_8:
 871     while (true) {
 872       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
 873       case _ORL:
 874       case SC_OR:
 875         ;
 876         break;
 877       default:
 878         jj_la1[23] = jj_gen;
 879         break label_8;
 880       }
 881       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
 882       case SC_OR:
 883         operator = jj_consume_token(SC_OR);
 884         break;
 885       case _ORL:
 886         operator = jj_consume_token(_ORL);
 887         break;
 888       default:
 889         jj_la1[24] = jj_gen;
 890         jj_consume_token(-1);
 891         throw new ParseException();
 892       }
 893       expr2 = ConditionalAndExpression();
 894       buff.append(operator.image);
 895       buff.append(expr2);
 896     }
 897     {if (true) return buff.toString();}
 898     throw new Error("Missing return statement in function");
 899   }
 900
 901   static final public String ConditionalAndExpression() throws ParseException {
 902   String expr;
 903   Token operator;
 904   String expr2 = null;
 905   StringBuffer buff = new StringBuffer();
 906     expr = ConcatExpression();
 907     buff.append(expr);
 908     label_9:
 909     while (true) {
 910       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
 911       case _ANDL:
 912       case SC_AND:
 913         ;
 914         break;
 915       default:
 916         jj_la1[25] = jj_gen;
 917         break label_9;
 918       }
 919       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
 920       case SC_AND:
 921         operator = jj_consume_token(SC_AND);
 922         break;
 923       case _ANDL:
 924         operator = jj_consume_token(_ANDL);
 925         break;
 926       default:
 927         jj_la1[26] = jj_gen;
 928         jj_consume_token(-1);
 929         throw new ParseException();
 930       }
 931       expr2 = ConcatExpression();
 932       buff.append(operator.image);
 933       buff.append(expr2);
 934     }
 935     {if (true) return buff.toString();}
 936     throw new Error("Missing return statement in function");
 937   }
 938
 939   static final public String ConcatExpression() throws ParseException {
 940   String expr;
 941   String expr2 = null;
 942   StringBuffer buff = new StringBuffer();
 943     expr = InclusiveOrExpression();
 944     buff.append(expr);
 945     label_10:
 946     while (true) {
 947       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
 948       case DOT:
 949         ;
 950         break;
 951       default:
 952         jj_la1[27] = jj_gen;
 953         break label_10;
 954       }
 955       jj_consume_token(DOT);
 956       expr2 = InclusiveOrExpression();
 957     buff.append(".");
 958     buff.append(expr2);
 959     }
 960     {if (true) return buff.toString();}
 961     throw new Error("Missing return statement in function");
 962   }
 963
 964   static final public String InclusiveOrExpression() throws ParseException {
 965   String expr;
 966   String expr2 = null;
 967   StringBuffer buff = new StringBuffer();
 968     expr = ExclusiveOrExpression();
 969     buff.append(expr);
 970     label_11:
 971     while (true) {
 972       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
 973       case BIT_OR:
 974         ;
 975         break;
 976       default:
 977         jj_la1[28] = jj_gen;
 978         break label_11;
 979       }
 980       jj_consume_token(BIT_OR);
 981       expr2 = ExclusiveOrExpression();
 982     buff.append("|");
 983     buff.append(expr2);
 984     }
 985     {if (true) return buff.toString();}
 986     throw new Error("Missing return statement in function");
 987   }
 988
 989   static final public String ExclusiveOrExpression() throws ParseException {
 990   String expr;
 991   String expr2 = null;
 992   StringBuffer buff = new StringBuffer();
 993     expr = AndExpression();
 994     buff.append(expr);
 995     label_12:
 996     while (true) {
 997       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
 998       case XOR:
 999         ;
1000         break;
1001       default:
1002         jj_la1[29] = jj_gen;
1003         break label_12;
1004       }
1005       jj_consume_token(XOR);
1006       expr2 = AndExpression();
1007     buff.append("^");
1008     buff.append(expr2);
1009     }
1010     {if (true) return buff.toString();}
1011     throw new Error("Missing return statement in function");
1012   }
1013
1014   static final public String AndExpression() throws ParseException {
1015   String expr;
1016   String expr2 = null;
1017   StringBuffer buff = new StringBuffer();
1018     expr = EqualityExpression();
1019     buff.append(expr);
1020     label_13:
1021     while (true) {
1022       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1023       case BIT_AND:
1024         ;
1025         break;
1026       default:
1027         jj_la1[30] = jj_gen;
1028         break label_13;
1029       }
1030       jj_consume_token(BIT_AND);
1031       expr2 = EqualityExpression();
1032     buff.append("&");
1033     buff.append(expr2);
1034     }
1035     {if (true) return buff.toString();}
1036     throw new Error("Missing return statement in function");
1037   }
1038
1039   static final public String EqualityExpression() throws ParseException {
1040   String expr;
1041   Token operator;
1042   String expr2;
1043   StringBuffer buff = new StringBuffer();
1044     expr = RelationalExpression();
1045    buff.append(expr);
1046     label_14:
1047     while (true) {
1048       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1049       case EQ:
1050       case NE:
1051         ;
1052         break;
1053       default:
1054         jj_la1[31] = jj_gen;
1055         break label_14;
1056       }
1057       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1058       case EQ:
1059         operator = jj_consume_token(EQ);
1060         break;
1061       case NE:
1062         operator = jj_consume_token(NE);
1063         break;
1064       default:
1065         jj_la1[32] = jj_gen;
1066         jj_consume_token(-1);
1067         throw new ParseException();
1068       }
1069       expr2 = RelationalExpression();
1070     buff.append(operator.image);
1071     buff.append(expr2);
1072     }
1073    {if (true) return buff.toString();}
1074     throw new Error("Missing return statement in function");
1075   }
1076
1077   static final public String RelationalExpression() throws ParseException {
1078   String expr;
1079   Token operator;
1080   String expr2;
1081   StringBuffer buff = new StringBuffer();
1082     expr = ShiftExpression();
1083    buff.append(expr);
1084     label_15:
1085     while (true) {
1086       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1087       case GT:
1088       case LT:
1089       case LE:
1090       case GE:
1091         ;
1092         break;
1093       default:
1094         jj_la1[33] = jj_gen;
1095         break label_15;
1096       }
1097       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1098       case LT:
1099         operator = jj_consume_token(LT);
1100         break;
1101       case GT:
1102         operator = jj_consume_token(GT);
1103         break;
1104       case LE:
1105         operator = jj_consume_token(LE);
1106         break;
1107       case GE:
1108         operator = jj_consume_token(GE);
1109         break;
1110       default:
1111         jj_la1[34] = jj_gen;
1112         jj_consume_token(-1);
1113         throw new ParseException();
1114       }
1115       expr2 = ShiftExpression();
1116     buff.append(operator.image);
1117     buff.append(expr2);
1118     }
1119    {if (true) return buff.toString();}
1120     throw new Error("Missing return statement in function");
1121   }
1122
1123   static final public String ShiftExpression() throws ParseException {
1124   String expr;
1125   Token operator;
1126   String expr2;
1127   StringBuffer buff = new StringBuffer();
1128     expr = AdditiveExpression();
1129    buff.append(expr);
1130     label_16:
1131     while (true) {
1132       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1133       case LSHIFT:
1134       case RSIGNEDSHIFT:
1135       case RUNSIGNEDSHIFT:
1136         ;
1137         break;
1138       default:
1139         jj_la1[35] = jj_gen;
1140         break label_16;
1141       }
1142       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1143       case LSHIFT:
1144         operator = jj_consume_token(LSHIFT);
1145         break;
1146       case RSIGNEDSHIFT:
1147         operator = jj_consume_token(RSIGNEDSHIFT);
1148         break;
1149       case RUNSIGNEDSHIFT:
1150         operator = jj_consume_token(RUNSIGNEDSHIFT);
1151         break;
1152       default:
1153         jj_la1[36] = jj_gen;
1154         jj_consume_token(-1);
1155         throw new ParseException();
1156       }
1157       expr2 = AdditiveExpression();
1158     buff.append(operator.image);
1159     buff.append(expr2);
1160     }
1161    {if (true) return buff.toString();}
1162     throw new Error("Missing return statement in function");
1163   }
1164
1165   static final public String AdditiveExpression() throws ParseException {
1166   String expr;
1167   Token operator;
1168   String expr2;
1169   StringBuffer buff = new StringBuffer();
1170     expr = MultiplicativeExpression();
1171    buff.append(expr);
1172     label_17:
1173     while (true) {
1174       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1175       case PLUS:
1176       case MINUS:
1177         ;
1178         break;
1179       default:
1180         jj_la1[37] = jj_gen;
1181         break label_17;
1182       }
1183       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1184       case PLUS:
1185         operator = jj_consume_token(PLUS);
1186         break;
1187       case MINUS:
1188         operator = jj_consume_token(MINUS);
1189         break;
1190       default:
1191         jj_la1[38] = jj_gen;
1192         jj_consume_token(-1);
1193         throw new ParseException();
1194       }
1195       expr2 = MultiplicativeExpression();
1196     buff.append(operator.image);
1197     buff.append(expr2);
1198     }
1199    {if (true) return buff.toString();}
1200     throw new Error("Missing return statement in function");
1201   }
1202
1203   static final public String MultiplicativeExpression() throws ParseException {
1204   String expr;
1205   Token operator;
1206   String expr2;
1207   StringBuffer buff = new StringBuffer();
1208     expr = UnaryExpression();
1209    buff.append(expr);
1210     label_18:
1211     while (true) {
1212       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1213       case STAR:
1214       case SLASH:
1215       case REM:
1216         ;
1217         break;
1218       default:
1219         jj_la1[39] = jj_gen;
1220         break label_18;
1221       }
1222       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1223       case STAR:
1224         operator = jj_consume_token(STAR);
1225         break;
1226       case SLASH:
1227         operator = jj_consume_token(SLASH);
1228         break;
1229       case REM:
1230         operator = jj_consume_token(REM);
1231         break;
1232       default:
1233         jj_la1[40] = jj_gen;
1234         jj_consume_token(-1);
1235         throw new ParseException();
1236       }
1237       expr2 = UnaryExpression();
1238     buff.append(operator.image);
1239     buff.append(expr2);
1240     }
1241    {if (true) return buff.toString();}
1242     throw new Error("Missing return statement in function");
1243   }
1244
1245   static final public String UnaryExpression() throws ParseException {
1246   String expr;
1247   StringBuffer buff = new StringBuffer();
1248     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1249     case AT:
1250       jj_consume_token(AT);
1251       expr = UnaryExpression();
1252    {if (true) return "@" + expr;}
1253       break;
1254     case PLUS:
1255     case MINUS:
1256       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1257       case PLUS:
1258         jj_consume_token(PLUS);
1259             buff.append("+");
1260         break;
1261       case MINUS:
1262         jj_consume_token(MINUS);
1263                                          buff.append("-");
1264         break;
1265       default:
1266         jj_la1[41] = jj_gen;
1267         jj_consume_token(-1);
1268         throw new ParseException();
1269       }
1270       expr = UnaryExpression();
1271     buff.append(expr);
1272     {if (true) return buff.toString();}
1273       break;
1274     case INCR:
1275       expr = PreIncrementExpression();
1276    {if (true) return expr;}
1277       break;
1278     case DECR:
1279       expr = PreDecrementExpression();
1280    {if (true) return expr;}
1281       break;
1282     case ARRAY:
1283     case FALSE:
1284     case NEW:
1285     case NULL:
1286     case TRUE:
1287     case INTEGER_LITERAL:
1288     case FLOATING_POINT_LITERAL:
1289     case STRING_LITERAL:
1290     case IDENTIFIER:
1291     case LPAREN:
1292     case DOLLAR:
1293     case BANG:
1294     case BIT_AND:
1295     case DOLLAR_ID:
1296       expr = UnaryExpressionNotPlusMinus();
1297    {if (true) return buff.toString();}
1298       break;
1299     default:
1300       jj_la1[42] = jj_gen;
1301       jj_consume_token(-1);
1302       throw new ParseException();
1303     }
1304     throw new Error("Missing return statement in function");
1305   }
1306
1307   static final public String PreIncrementExpression() throws ParseException {
1308 String expr;
1309     jj_consume_token(INCR);
1310     expr = PrimaryExpression();
1311    {if (true) return "++"+expr;}
1312     throw new Error("Missing return statement in function");
1313   }
1314
1315   static final public String PreDecrementExpression() throws ParseException {
1316 String expr;
1317     jj_consume_token(DECR);
1318     expr = PrimaryExpression();
1319    {if (true) return "--"+expr;}
1320     throw new Error("Missing return statement in function");
1321   }
1322
1323   static final public String UnaryExpressionNotPlusMinus() throws ParseException {
1324   String expr;
1325     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1326     case BANG:
1327       jj_consume_token(BANG);
1328       expr = UnaryExpression();
1329    {if (true) return "!" + expr;}
1330       break;
1331     default:
1332       jj_la1[43] = jj_gen;
1333       if (jj_2_3(2147483647)) {
1334         expr = CastExpression();
1335    {if (true) return expr;}
1336       } else {
1337         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1338         case ARRAY:
1339         case NEW:
1340         case IDENTIFIER:
1341         case DOLLAR:
1342         case BIT_AND:
1343         case DOLLAR_ID:
1344           expr = PostfixExpression();
1345    {if (true) return expr;}
1346           break;
1347         case FALSE:
1348         case NULL:
1349         case TRUE:
1350         case INTEGER_LITERAL:
1351         case FLOATING_POINT_LITERAL:
1352         case STRING_LITERAL:
1353           expr = Literal();
1354    {if (true) return expr;}
1355           break;
1356         case LPAREN:
1357           jj_consume_token(LPAREN);
1358           expr = Expression();
1359           jj_consume_token(RPAREN);
1360    {if (true) return "("+expr+")";}
1361           break;
1362         default:
1363           jj_la1[44] = jj_gen;
1364           jj_consume_token(-1);
1365           throw new ParseException();
1366         }
1367       }
1368     }
1369     throw new Error("Missing return statement in function");
1370   }
1371
1372   static final public String CastExpression() throws ParseException {
1373 String type;
1374 String expr;
1375     jj_consume_token(LPAREN);
1376     type = Type();
1377     jj_consume_token(RPAREN);
1378     expr = UnaryExpression();
1379    {if (true) return "(" + type + ")" + expr;}
1380     throw new Error("Missing return statement in function");
1381   }
1382
1383   static final public String PostfixExpression() throws ParseException {
1384   String expr;
1385   Token operator = null;
1386     expr = PrimaryExpression();
1387     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1388     case INCR:
1389     case DECR:
1390       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1391       case INCR:
1392         operator = jj_consume_token(INCR);
1393         break;
1394       case DECR:
1395         operator = jj_consume_token(DECR);
1396         break;
1397       default:
1398         jj_la1[45] = jj_gen;
1399         jj_consume_token(-1);
1400         throw new ParseException();
1401       }
1402       break;
1403     default:
1404       jj_la1[46] = jj_gen;
1405       ;
1406     }
1407     if (operator == null) {
1408       {if (true) return expr;}
1409     }
1410     {if (true) return expr + operator.image;}
1411     throw new Error("Missing return statement in function");
1412   }
1413
1414   static final public String PrimaryExpression() throws ParseException {
1415   Token identifier;
1416   String expr;
1417   StringBuffer buff = new StringBuffer();
1418     if (jj_2_4(2)) {
1419       identifier = jj_consume_token(IDENTIFIER);
1420       jj_consume_token(STATICCLASSACCESS);
1421       expr = ClassIdentifier();
1422    buff.append(identifier.image).append("::").append(expr);
1423       label_19:
1424       while (true) {
1425         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1426         case CLASSACCESS:
1427         case LPAREN:
1428         case LBRACKET:
1429           ;
1430           break;
1431         default:
1432           jj_la1[47] = jj_gen;
1433           break label_19;
1434         }
1435         expr = PrimarySuffix();
1436    buff.append(expr);
1437       }
1438    {if (true) return buff.toString();}
1439     } else {
1440       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1441       case NEW:
1442       case IDENTIFIER:
1443       case DOLLAR:
1444       case BIT_AND:
1445       case DOLLAR_ID:
1446         expr = PrimaryPrefix();
1447    buff.append(expr);
1448         label_20:
1449         while (true) {
1450           switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1451           case CLASSACCESS:
1452           case LPAREN:
1453           case LBRACKET:
1454             ;
1455             break;
1456           default:
1457             jj_la1[48] = jj_gen;
1458             break label_20;
1459           }
1460           expr = PrimarySuffix();
1461    buff.append(expr);
1462         }
1463    {if (true) return buff.toString();}
1464         break;
1465       case ARRAY:
1466         jj_consume_token(ARRAY);
1467         expr = ArrayInitializer();
1468    {if (true) return "array" + expr;}
1469         break;
1470       default:
1471         jj_la1[49] = jj_gen;
1472         jj_consume_token(-1);
1473         throw new ParseException();
1474       }
1475     }
1476     throw new Error("Missing return statement in function");
1477   }
1478
1479   static final public String PrimaryPrefix() throws ParseException {
1480   String expr;
1481   Token token = null;
1482     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1483     case IDENTIFIER:
1484       token = jj_consume_token(IDENTIFIER);
1485    {if (true) return token.image;}
1486       break;
1487     case NEW:
1488     case BIT_AND:
1489       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1490       case BIT_AND:
1491         token = jj_consume_token(BIT_AND);
1492         break;
1493       default:
1494         jj_la1[50] = jj_gen;
1495         ;
1496       }
1497       jj_consume_token(NEW);
1498       expr = ClassIdentifier();
1499     if (token == null) {
1500       {if (true) return "new " + expr;}
1501     }
1502     {if (true) return "new " + expr;}
1503       break;
1504     case DOLLAR:
1505     case DOLLAR_ID:
1506       expr = VariableDeclaratorId();
1507    {if (true) return expr;}
1508       break;
1509     default:
1510       jj_la1[51] = jj_gen;
1511       jj_consume_token(-1);
1512       throw new ParseException();
1513     }
1514     throw new Error("Missing return statement in function");
1515   }
1516
1517   static final public String ClassIdentifier() throws ParseException {
1518   String expr;
1519   Token token;
1520     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1521     case IDENTIFIER:
1522       token = jj_consume_token(IDENTIFIER);
1523    {if (true) return token.image;}
1524       break;
1525     case DOLLAR:
1526     case DOLLAR_ID:
1527       expr = VariableDeclaratorId();
1528    {if (true) return expr;}
1529       break;
1530     default:
1531       jj_la1[52] = jj_gen;
1532       jj_consume_token(-1);
1533       throw new ParseException();
1534     }
1535     throw new Error("Missing return statement in function");
1536   }
1537
1538   static final public String PrimarySuffix() throws ParseException {
1539   String expr;
1540     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1541     case LPAREN:
1542       expr = Arguments();
1543    {if (true) return expr;}
1544       break;
1545     case CLASSACCESS:
1546     case LBRACKET:
1547       expr = VariableSuffix();
1548    {if (true) return expr;}
1549       break;
1550     default:
1551       jj_la1[53] = jj_gen;
1552       jj_consume_token(-1);
1553       throw new ParseException();
1554     }
1555     throw new Error("Missing return statement in function");
1556   }
1557
1558   static final public String VariableSuffix() throws ParseException {
1559   String expr = null;
1560     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1561     case CLASSACCESS:
1562       jj_consume_token(CLASSACCESS);
1563       expr = VariableName();
1564    {if (true) return "->" + expr;}
1565       break;
1566     case LBRACKET:
1567       jj_consume_token(LBRACKET);
1568       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1569       case ARRAY:
1570       case PRINT:
1571       case FALSE:
1572       case NEW:
1573       case NULL:
1574       case TRUE:
1575       case INTEGER_LITERAL:
1576       case FLOATING_POINT_LITERAL:
1577       case STRING_LITERAL:
1578       case IDENTIFIER:
1579       case LPAREN:
1580       case AT:
1581       case DOLLAR:
1582       case BANG:
1583       case INCR:
1584       case DECR:
1585       case PLUS:
1586       case MINUS:
1587       case BIT_AND:
1588       case DOLLAR_ID:
1589         expr = Expression();
1590         break;
1591       default:
1592         jj_la1[54] = jj_gen;
1593         ;
1594       }
1595       jj_consume_token(RBRACKET);
1596     if(expr == null) {
1597       {if (true) return "[]";}
1598     }
1599     {if (true) return "[" + expr + "]";}
1600       break;
1601     default:
1602       jj_la1[55] = jj_gen;
1603       jj_consume_token(-1);
1604       throw new ParseException();
1605     }
1606     throw new Error("Missing return statement in function");
1607   }
1608
1609   static final public String Literal() throws ParseException {
1610   String expr;
1611   Token token;
1612     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1613     case INTEGER_LITERAL:
1614       token = jj_consume_token(INTEGER_LITERAL);
1615    {if (true) return token.image;}
1616       break;
1617     case FLOATING_POINT_LITERAL:
1618       token = jj_consume_token(FLOATING_POINT_LITERAL);
1619    {if (true) return token.image;}
1620       break;
1621     case STRING_LITERAL:
1622       try {
1623         token = jj_consume_token(STRING_LITERAL);
1624    {if (true) return token.image;}
1625       } catch (TokenMgrError e) {
1626     errorMessage = "unterminated string";
1627     errorLevel   = ERROR;
1628     {if (true) throw generateParseException();}
1629       }
1630       break;
1631     case FALSE:
1632     case TRUE:
1633       expr = BooleanLiteral();
1634    {if (true) return expr;}
1635       break;
1636     case NULL:
1637       expr = NullLiteral();
1638    {if (true) return expr;}
1639       break;
1640     default:
1641       jj_la1[56] = jj_gen;
1642       jj_consume_token(-1);
1643       throw new ParseException();
1644     }
1645     throw new Error("Missing return statement in function");
1646   }
1647
1648   static final public String BooleanLiteral() throws ParseException {
1649     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1650     case TRUE:
1651       jj_consume_token(TRUE);
1652    {if (true) return "true";}
1653       break;
1654     case FALSE:
1655       jj_consume_token(FALSE);
1656    {if (true) return "false";}
1657       break;
1658     default:
1659       jj_la1[57] = jj_gen;
1660       jj_consume_token(-1);
1661       throw new ParseException();
1662     }
1663     throw new Error("Missing return statement in function");
1664   }
1665
1666   static final public String NullLiteral() throws ParseException {
1667     jj_consume_token(NULL);
1668    {if (true) return "null";}
1669     throw new Error("Missing return statement in function");
1670   }
1671
1672   static final public String Arguments() throws ParseException {
1673 String expr = null;
1674     jj_consume_token(LPAREN);
1675     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1676     case ARRAY:
1677     case PRINT:
1678     case FALSE:
1679     case NEW:
1680     case NULL:
1681     case TRUE:
1682     case INTEGER_LITERAL:
1683     case FLOATING_POINT_LITERAL:
1684     case STRING_LITERAL:
1685     case IDENTIFIER:
1686     case LPAREN:
1687     case AT:
1688     case DOLLAR:
1689     case BANG:
1690     case INCR:
1691     case DECR:
1692     case PLUS:
1693     case MINUS:
1694     case BIT_AND:
1695     case DOLLAR_ID:
1696       expr = ArgumentList();
1697       break;
1698     default:
1699       jj_la1[58] = jj_gen;
1700       ;
1701     }
1702     try {
1703       jj_consume_token(RPAREN);
1704     } catch (ParseException e) {
1705     errorMessage = "')' expected to close the argument list";
1706     errorLevel   = ERROR;
1707     {if (true) throw e;}
1708     }
1709   if (expr == null) {
1710     {if (true) return "()";}
1711   }
1712   {if (true) return "(" + expr + ")";}
1713     throw new Error("Missing return statement in function");
1714   }
1715
1716   static final public String ArgumentList() throws ParseException {
1717 String expr;
1718 StringBuffer buff = new StringBuffer();
1719     expr = Expression();
1720    buff.append(expr);
1721     label_21:
1722     while (true) {
1723       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1724       case COMMA:
1725         ;
1726         break;
1727       default:
1728         jj_la1[59] = jj_gen;
1729         break label_21;
1730       }
1731       jj_consume_token(COMMA);
1732       try {
1733         expr = Expression();
1734       } catch (ParseException e) {
1735         errorMessage = "expression expected after a comma in argument list";
1736         errorLevel   = ERROR;
1737         {if (true) throw e;}
1738       }
1739       buff.append(",").append("expr");
1740     }
1741     {if (true) return buff.toString();}
1742     throw new Error("Missing return statement in function");
1743   }
1744
1745 /*
1746  * Statement syntax follows.
1747  */
1748   static final public void Statement() throws ParseException {
1749     if (jj_2_5(2)) {
1750       Expression();
1751       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1752       case SEMICOLON:
1753         jj_consume_token(SEMICOLON);
1754         break;
1755       case 127:
1756         jj_consume_token(127);
1757         break;
1758       default:
1759         jj_la1[60] = jj_gen;
1760         jj_consume_token(-1);
1761         throw new ParseException();
1762       }
1763     } else if (jj_2_6(2)) {
1764       LabeledStatement();
1765     } else {
1766       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1767       case LBRACE:
1768         Block();
1769         break;
1770       case SEMICOLON:
1771         EmptyStatement();
1772         break;
1773       case ARRAY:
1774       case NEW:
1775       case IDENTIFIER:
1776       case DOLLAR:
1777       case INCR:
1778       case DECR:
1779       case BIT_AND:
1780       case DOLLAR_ID:
1781         StatementExpression();
1782         try {
1783           jj_consume_token(SEMICOLON);
1784         } catch (ParseException e) {
1785     errorMessage = "';' expected after expression";
1786     errorLevel   = ERROR;
1787     {if (true) throw e;}
1788         }
1789         break;
1790       case SWITCH:
1791         SwitchStatement();
1792         break;
1793       case IF:
1794         IfStatement();
1795         break;
1796       case WHILE:
1797         WhileStatement();
1798         break;
1799       case DO:
1800         DoStatement();
1801         break;
1802       case FOR:
1803         ForStatement();
1804         break;
1805       case BREAK:
1806         BreakStatement();
1807         break;
1808       case CONTINUE:
1809         ContinueStatement();
1810         break;
1811       case RETURN:
1812         ReturnStatement();
1813         break;
1814       case ECHO:
1815         EchoStatement();
1816         break;
1817       case INCLUDE:
1818       case REQUIRE:
1819       case INCLUDE_ONCE:
1820       case REQUIRE_ONCE:
1821         IncludeStatement();
1822         break;
1823       case STATIC:
1824         StaticStatement();
1825         break;
1826       case GLOBAL:
1827         GlobalStatement();
1828         break;
1829       default:
1830         jj_la1[61] = jj_gen;
1831         jj_consume_token(-1);
1832         throw new ParseException();
1833       }
1834     }
1835   }
1836
1837   static final public void IncludeStatement() throws ParseException {
1838     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1839     case REQUIRE:
1840       jj_consume_token(REQUIRE);
1841       Expression();
1842       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1843       case SEMICOLON:
1844         jj_consume_token(SEMICOLON);
1845         break;
1846       case 127:
1847         jj_consume_token(127);
1848         break;
1849       default:
1850         jj_la1[62] = jj_gen;
1851         jj_consume_token(-1);
1852         throw new ParseException();
1853       }
1854       break;
1855     case REQUIRE_ONCE:
1856       jj_consume_token(REQUIRE_ONCE);
1857       Expression();
1858       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1859       case SEMICOLON:
1860         jj_consume_token(SEMICOLON);
1861         break;
1862       case 127:
1863         jj_consume_token(127);
1864         break;
1865       default:
1866         jj_la1[63] = jj_gen;
1867         jj_consume_token(-1);
1868         throw new ParseException();
1869       }
1870       break;
1871     case INCLUDE:
1872       jj_consume_token(INCLUDE);
1873       Expression();
1874       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1875       case SEMICOLON:
1876         jj_consume_token(SEMICOLON);
1877         break;
1878       case 127:
1879         jj_consume_token(127);
1880         break;
1881       default:
1882         jj_la1[64] = jj_gen;
1883         jj_consume_token(-1);
1884         throw new ParseException();
1885       }
1886       break;
1887     case INCLUDE_ONCE:
1888       jj_consume_token(INCLUDE_ONCE);
1889       Expression();
1890       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1891       case SEMICOLON:
1892         jj_consume_token(SEMICOLON);
1893         break;
1894       case 127:
1895         jj_consume_token(127);
1896         break;
1897       default:
1898         jj_la1[65] = jj_gen;
1899         jj_consume_token(-1);
1900         throw new ParseException();
1901       }
1902       break;
1903     default:
1904       jj_la1[66] = jj_gen;
1905       jj_consume_token(-1);
1906       throw new ParseException();
1907     }
1908   }
1909
1910   static final public String PrintExpression() throws ParseException {
1911   StringBuffer buff = new StringBuffer("print ");
1912   String expr;
1913     jj_consume_token(PRINT);
1914     expr = Expression();
1915     buff.append(expr);
1916     {if (true) return buff.toString();}
1917     throw new Error("Missing return statement in function");
1918   }
1919
1920   static final public void EchoStatement() throws ParseException {
1921     jj_consume_token(ECHO);
1922     Expression();
1923     label_22:
1924     while (true) {
1925       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1926       case COMMA:
1927         ;
1928         break;
1929       default:
1930         jj_la1[67] = jj_gen;
1931         break label_22;
1932       }
1933       jj_consume_token(COMMA);
1934       Expression();
1935     }
1936     try {
1937       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1938       case SEMICOLON:
1939         jj_consume_token(SEMICOLON);
1940         break;
1941       case 127:
1942         jj_consume_token(127);
1943         break;
1944       default:
1945         jj_la1[68] = jj_gen;
1946         jj_consume_token(-1);
1947         throw new ParseException();
1948       }
1949     } catch (ParseException e) {
1950     errorMessage = "';' expected after 'echo' statement";
1951     errorLevel   = ERROR;
1952     {if (true) throw e;}
1953     }
1954   }
1955
1956   static final public void GlobalStatement() throws ParseException {
1957     jj_consume_token(GLOBAL);
1958     VariableDeclaratorId();
1959     label_23:
1960     while (true) {
1961       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1962       case COMMA:
1963         ;
1964         break;
1965       default:
1966         jj_la1[69] = jj_gen;
1967         break label_23;
1968       }
1969       jj_consume_token(COMMA);
1970       VariableDeclaratorId();
1971     }
1972     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1973     case SEMICOLON:
1974       jj_consume_token(SEMICOLON);
1975       break;
1976     case 127:
1977       jj_consume_token(127);
1978       break;
1979     default:
1980       jj_la1[70] = jj_gen;
1981       jj_consume_token(-1);
1982       throw new ParseException();
1983     }
1984   }
1985
1986   static final public void StaticStatement() throws ParseException {
1987     jj_consume_token(STATIC);
1988     VariableDeclarator();
1989     label_24:
1990     while (true) {
1991       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1992       case COMMA:
1993         ;
1994         break;
1995       default:
1996         jj_la1[71] = jj_gen;
1997         break label_24;
1998       }
1999       jj_consume_token(COMMA);
2000       VariableDeclarator();
2001     }
2002     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2003     case SEMICOLON:
2004       jj_consume_token(SEMICOLON);
2005       break;
2006     case 127:
2007       jj_consume_token(127);
2008       break;
2009     default:
2010       jj_la1[72] = jj_gen;
2011       jj_consume_token(-1);
2012       throw new ParseException();
2013     }
2014   }
2015
2016   static final public void LabeledStatement() throws ParseException {
2017     jj_consume_token(IDENTIFIER);
2018     jj_consume_token(COLON);
2019     Statement();
2020   }
2021
2022   static final public void Block() throws ParseException {
2023     jj_consume_token(LBRACE);
2024     label_25:
2025     while (true) {
2026       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2027       case CLASS:
2028       case FUNCTION:
2029       case IF:
2030       case ARRAY:
2031       case PRINT:
2032       case ECHO:
2033       case INCLUDE:
2034       case REQUIRE:
2035       case INCLUDE_ONCE:
2036       case REQUIRE_ONCE:
2037       case GLOBAL:
2038       case STATIC:
2039       case BREAK:
2040       case CONTINUE:
2041       case DO:
2042       case FALSE:
2043       case FOR:
2044       case NEW:
2045       case NULL:
2046       case RETURN:
2047       case SWITCH:
2048       case TRUE:
2049       case WHILE:
2050       case INTEGER_LITERAL:
2051       case FLOATING_POINT_LITERAL:
2052       case STRING_LITERAL:
2053       case IDENTIFIER:
2054       case LPAREN:
2055       case LBRACE:
2056       case SEMICOLON:
2057       case AT:
2058       case DOLLAR:
2059       case BANG:
2060       case INCR:
2061       case DECR:
2062       case PLUS:
2063       case MINUS:
2064       case BIT_AND:
2065       case DOLLAR_ID:
2066         ;
2067         break;
2068       default:
2069         jj_la1[73] = jj_gen;
2070         break label_25;
2071       }
2072       BlockStatement();
2073     }
2074     jj_consume_token(RBRACE);
2075   }
2076
2077   static final public void BlockStatement() throws ParseException {
2078     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2079     case IF:
2080     case ARRAY:
2081     case PRINT:
2082     case ECHO:
2083     case INCLUDE:
2084     case REQUIRE:
2085     case INCLUDE_ONCE:
2086     case REQUIRE_ONCE:
2087     case GLOBAL:
2088     case STATIC:
2089     case BREAK:
2090     case CONTINUE:
2091     case DO:
2092     case FALSE:
2093     case FOR:
2094     case NEW:
2095     case NULL:
2096     case RETURN:
2097     case SWITCH:
2098     case TRUE:
2099     case WHILE:
2100     case INTEGER_LITERAL:
2101     case FLOATING_POINT_LITERAL:
2102     case STRING_LITERAL:
2103     case IDENTIFIER:
2104     case LPAREN:
2105     case LBRACE:
2106     case SEMICOLON:
2107     case AT:
2108     case DOLLAR:
2109     case BANG:
2110     case INCR:
2111     case DECR:
2112     case PLUS:
2113     case MINUS:
2114     case BIT_AND:
2115     case DOLLAR_ID:
2116       Statement();
2117       break;
2118     case CLASS:
2119       ClassDeclaration();
2120       break;
2121     case FUNCTION:
2122       MethodDeclaration();
2123       break;
2124     default:
2125       jj_la1[74] = jj_gen;
2126       jj_consume_token(-1);
2127       throw new ParseException();
2128     }
2129   }
2130
2131   static final public void LocalVariableDeclaration() throws ParseException {
2132     VariableDeclarator();
2133     label_26:
2134     while (true) {
2135       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2136       case COMMA:
2137         ;
2138         break;
2139       default:
2140         jj_la1[75] = jj_gen;
2141         break label_26;
2142       }
2143       jj_consume_token(COMMA);
2144       VariableDeclarator();
2145     }
2146   }
2147
2148   static final public void EmptyStatement() throws ParseException {
2149     jj_consume_token(SEMICOLON);
2150   }
2151
2152   static final public void StatementExpression() throws ParseException {
2153     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2154     case INCR:
2155       PreIncrementExpression();
2156       break;
2157     case DECR:
2158       PreDecrementExpression();
2159       break;
2160     case ARRAY:
2161     case NEW:
2162     case IDENTIFIER:
2163     case DOLLAR:
2164     case BIT_AND:
2165     case DOLLAR_ID:
2166       PrimaryExpression();
2167       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2168       case ASSIGN:
2169       case INCR:
2170       case DECR:
2171       case PLUSASSIGN:
2172       case MINUSASSIGN:
2173       case STARASSIGN:
2174       case SLASHASSIGN:
2175       case ANDASSIGN:
2176       case ORASSIGN:
2177       case XORASSIGN:
2178       case DOTASSIGN:
2179       case REMASSIGN:
2180       case LSHIFTASSIGN:
2181       case RSIGNEDSHIFTASSIGN:
2182       case RUNSIGNEDSHIFTASSIGN:
2183         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2184         case INCR:
2185           jj_consume_token(INCR);
2186           break;
2187         case DECR:
2188           jj_consume_token(DECR);
2189           break;
2190         case ASSIGN:
2191         case PLUSASSIGN:
2192         case MINUSASSIGN:
2193         case STARASSIGN:
2194         case SLASHASSIGN:
2195         case ANDASSIGN:
2196         case ORASSIGN:
2197         case XORASSIGN:
2198         case DOTASSIGN:
2199         case REMASSIGN:
2200         case LSHIFTASSIGN:
2201         case RSIGNEDSHIFTASSIGN:
2202         case RUNSIGNEDSHIFTASSIGN:
2203           AssignmentOperator();
2204           Expression();
2205           break;
2206         default:
2207           jj_la1[76] = jj_gen;
2208           jj_consume_token(-1);
2209           throw new ParseException();
2210         }
2211         break;
2212       default:
2213         jj_la1[77] = jj_gen;
2214         ;
2215       }
2216       break;
2217     default:
2218       jj_la1[78] = jj_gen;
2219       jj_consume_token(-1);
2220       throw new ParseException();
2221     }
2222   }
2223
2224   static final public void SwitchStatement() throws ParseException {
2225     jj_consume_token(SWITCH);
2226     jj_consume_token(LPAREN);
2227     Expression();
2228     jj_consume_token(RPAREN);
2229     jj_consume_token(LBRACE);
2230     label_27:
2231     while (true) {
2232       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2233       case CASE:
2234       case _DEFAULT:
2235         ;
2236         break;
2237       default:
2238         jj_la1[79] = jj_gen;
2239         break label_27;
2240       }
2241       SwitchLabel();
2242       label_28:
2243       while (true) {
2244         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2245         case CLASS:
2246         case FUNCTION:
2247         case IF:
2248         case ARRAY:
2249         case PRINT:
2250         case ECHO:
2251         case INCLUDE:
2252         case REQUIRE:
2253         case INCLUDE_ONCE:
2254         case REQUIRE_ONCE:
2255         case GLOBAL:
2256         case STATIC:
2257         case BREAK:
2258         case CONTINUE:
2259         case DO:
2260         case FALSE:
2261         case FOR:
2262         case NEW:
2263         case NULL:
2264         case RETURN:
2265         case SWITCH:
2266         case TRUE:
2267         case WHILE:
2268         case INTEGER_LITERAL:
2269         case FLOATING_POINT_LITERAL:
2270         case STRING_LITERAL:
2271         case IDENTIFIER:
2272         case LPAREN:
2273         case LBRACE:
2274         case SEMICOLON:
2275         case AT:
2276         case DOLLAR:
2277         case BANG:
2278         case INCR:
2279         case DECR:
2280         case PLUS:
2281         case MINUS:
2282         case BIT_AND:
2283         case DOLLAR_ID:
2284           ;
2285           break;
2286         default:
2287           jj_la1[80] = jj_gen;
2288           break label_28;
2289         }
2290         BlockStatement();
2291       }
2292     }
2293     jj_consume_token(RBRACE);
2294   }
2295
2296   static final public void SwitchLabel() throws ParseException {
2297     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2298     case CASE:
2299       jj_consume_token(CASE);
2300       Expression();
2301       jj_consume_token(COLON);
2302       break;
2303     case _DEFAULT:
2304       jj_consume_token(_DEFAULT);
2305       jj_consume_token(COLON);
2306       break;
2307     default:
2308       jj_la1[81] = jj_gen;
2309       jj_consume_token(-1);
2310       throw new ParseException();
2311     }
2312   }
2313
2314   static final public void IfStatement() throws ParseException {
2315     jj_consume_token(IF);
2316     Condition("if");
2317     Statement();
2318     label_29:
2319     while (true) {
2320       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2321       case ELSEIF:
2322         ;
2323         break;
2324       default:
2325         jj_la1[82] = jj_gen;
2326         break label_29;
2327       }
2328       ElseIfStatement();
2329     }
2330     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2331     case ELSE:
2332       jj_consume_token(ELSE);
2333       Statement();
2334       break;
2335     default:
2336       jj_la1[83] = jj_gen;
2337       ;
2338     }
2339   }
2340
2341   static final public void Condition(String keyword) throws ParseException {
2342     try {
2343       jj_consume_token(LPAREN);
2344     } catch (ParseException e) {
2345     errorMessage = "'(' expected after " + keyword + " keyword";
2346     errorLevel   = ERROR;
2347     {if (true) throw e;}
2348     }
2349     Expression();
2350     try {
2351       jj_consume_token(RPAREN);
2352     } catch (ParseException e) {
2353     errorMessage = "')' expected after " + keyword + " keyword";
2354     errorLevel   = ERROR;
2355     {if (true) throw e;}
2356     }
2357   }
2358
2359   static final public void ElseIfStatement() throws ParseException {
2360     jj_consume_token(ELSEIF);
2361     Condition("elseif");
2362     Statement();
2363   }
2364
2365   static final public void WhileStatement() throws ParseException {
2366     jj_consume_token(WHILE);
2367     Condition("while");
2368     WhileStatement0();
2369   }
2370
2371   static final public void WhileStatement0() throws ParseException {
2372     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2373     case COLON:
2374       jj_consume_token(COLON);
2375       label_30:
2376       while (true) {
2377         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2378         case IF:
2379         case ARRAY:
2380         case PRINT:
2381         case ECHO:
2382         case INCLUDE:
2383         case REQUIRE:
2384         case INCLUDE_ONCE:
2385         case REQUIRE_ONCE:
2386         case GLOBAL:
2387         case STATIC:
2388         case BREAK:
2389         case CONTINUE:
2390         case DO:
2391         case FALSE:
2392         case FOR:
2393         case NEW:
2394         case NULL:
2395         case RETURN:
2396         case SWITCH:
2397         case TRUE:
2398         case WHILE:
2399         case INTEGER_LITERAL:
2400         case FLOATING_POINT_LITERAL:
2401         case STRING_LITERAL:
2402         case IDENTIFIER:
2403         case LPAREN:
2404         case LBRACE:
2405         case SEMICOLON:
2406         case AT:
2407         case DOLLAR:
2408         case BANG:
2409         case INCR:
2410         case DECR:
2411         case PLUS:
2412         case MINUS:
2413         case BIT_AND:
2414         case DOLLAR_ID:
2415           ;
2416           break;
2417         default:
2418           jj_la1[84] = jj_gen;
2419           break label_30;
2420         }
2421         Statement();
2422       }
2423       jj_consume_token(ENDWHILE);
2424       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2425       case SEMICOLON:
2426         jj_consume_token(SEMICOLON);
2427         break;
2428       case 127:
2429         jj_consume_token(127);
2430         break;
2431       default:
2432         jj_la1[85] = jj_gen;
2433         jj_consume_token(-1);
2434         throw new ParseException();
2435       }
2436       break;
2437     case IF:
2438     case ARRAY:
2439     case PRINT:
2440     case ECHO:
2441     case INCLUDE:
2442     case REQUIRE:
2443     case INCLUDE_ONCE:
2444     case REQUIRE_ONCE:
2445     case GLOBAL:
2446     case STATIC:
2447     case BREAK:
2448     case CONTINUE:
2449     case DO:
2450     case FALSE:
2451     case FOR:
2452     case NEW:
2453     case NULL:
2454     case RETURN:
2455     case SWITCH:
2456     case TRUE:
2457     case WHILE:
2458     case INTEGER_LITERAL:
2459     case FLOATING_POINT_LITERAL:
2460     case STRING_LITERAL:
2461     case IDENTIFIER:
2462     case LPAREN:
2463     case LBRACE:
2464     case SEMICOLON:
2465     case AT:
2466     case DOLLAR:
2467     case BANG:
2468     case INCR:
2469     case DECR:
2470     case PLUS:
2471     case MINUS:
2472     case BIT_AND:
2473     case DOLLAR_ID:
2474       Statement();
2475       break;
2476     default:
2477       jj_la1[86] = jj_gen;
2478       jj_consume_token(-1);
2479       throw new ParseException();
2480     }
2481   }
2482
2483   static final public void DoStatement() throws ParseException {
2484     jj_consume_token(DO);
2485     Statement();
2486     jj_consume_token(WHILE);
2487     Condition("while");
2488     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2489     case SEMICOLON:
2490       jj_consume_token(SEMICOLON);
2491       break;
2492     case 127:
2493       jj_consume_token(127);
2494       break;
2495     default:
2496       jj_la1[87] = jj_gen;
2497       jj_consume_token(-1);
2498       throw new ParseException();
2499     }
2500   }
2501
2502   static final public void ForStatement() throws ParseException {
2503     jj_consume_token(FOR);
2504     jj_consume_token(LPAREN);
2505     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2506     case ARRAY:
2507     case NEW:
2508     case IDENTIFIER:
2509     case DOLLAR:
2510     case INCR:
2511     case DECR:
2512     case BIT_AND:
2513     case DOLLAR_ID:
2514       ForInit();
2515       break;
2516     default:
2517       jj_la1[88] = jj_gen;
2518       ;
2519     }
2520     jj_consume_token(SEMICOLON);
2521     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2522     case ARRAY:
2523     case PRINT:
2524     case FALSE:
2525     case NEW:
2526     case NULL:
2527     case TRUE:
2528     case INTEGER_LITERAL:
2529     case FLOATING_POINT_LITERAL:
2530     case STRING_LITERAL:
2531     case IDENTIFIER:
2532     case LPAREN:
2533     case AT:
2534     case DOLLAR:
2535     case BANG:
2536     case INCR:
2537     case DECR:
2538     case PLUS:
2539     case MINUS:
2540     case BIT_AND:
2541     case DOLLAR_ID:
2542       Expression();
2543       break;
2544     default:
2545       jj_la1[89] = jj_gen;
2546       ;
2547     }
2548     jj_consume_token(SEMICOLON);
2549     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2550     case ARRAY:
2551     case NEW:
2552     case IDENTIFIER:
2553     case DOLLAR:
2554     case INCR:
2555     case DECR:
2556     case BIT_AND:
2557     case DOLLAR_ID:
2558       ForUpdate();
2559       break;
2560     default:
2561       jj_la1[90] = jj_gen;
2562       ;
2563     }
2564     jj_consume_token(RPAREN);
2565     Statement();
2566   }
2567
2568   static final public void ForInit() throws ParseException {
2569     if (jj_2_7(2147483647)) {
2570       LocalVariableDeclaration();
2571     } else {
2572       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2573       case ARRAY:
2574       case NEW:
2575       case IDENTIFIER:
2576       case DOLLAR:
2577       case INCR:
2578       case DECR:
2579       case BIT_AND:
2580       case DOLLAR_ID:
2581         StatementExpressionList();
2582         break;
2583       default:
2584         jj_la1[91] = jj_gen;
2585         jj_consume_token(-1);
2586         throw new ParseException();
2587       }
2588     }
2589   }
2590
2591   static final public void StatementExpressionList() throws ParseException {
2592     StatementExpression();
2593     label_31:
2594     while (true) {
2595       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2596       case COMMA:
2597         ;
2598         break;
2599       default:
2600         jj_la1[92] = jj_gen;
2601         break label_31;
2602       }
2603       jj_consume_token(COMMA);
2604       StatementExpression();
2605     }
2606   }
2607
2608   static final public void ForUpdate() throws ParseException {
2609     StatementExpressionList();
2610   }
2611
2612   static final public void BreakStatement() throws ParseException {
2613     jj_consume_token(BREAK);
2614     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2615     case IDENTIFIER:
2616       jj_consume_token(IDENTIFIER);
2617       break;
2618     default:
2619       jj_la1[93] = jj_gen;
2620       ;
2621     }
2622     jj_consume_token(SEMICOLON);
2623   }
2624
2625   static final public void ContinueStatement() throws ParseException {
2626     jj_consume_token(CONTINUE);
2627     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2628     case IDENTIFIER:
2629       jj_consume_token(IDENTIFIER);
2630       break;
2631     default:
2632       jj_la1[94] = jj_gen;
2633       ;
2634     }
2635     jj_consume_token(SEMICOLON);
2636   }
2637
2638   static final public void ReturnStatement() throws ParseException {
2639     jj_consume_token(RETURN);
2640     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2641     case ARRAY:
2642     case PRINT:
2643     case FALSE:
2644     case NEW:
2645     case NULL:
2646     case TRUE:
2647     case INTEGER_LITERAL:
2648     case FLOATING_POINT_LITERAL:
2649     case STRING_LITERAL:
2650     case IDENTIFIER:
2651     case LPAREN:
2652     case AT:
2653     case DOLLAR:
2654     case BANG:
2655     case INCR:
2656     case DECR:
2657     case PLUS:
2658     case MINUS:
2659     case BIT_AND:
2660     case DOLLAR_ID:
2661       Expression();
2662       break;
2663     default:
2664       jj_la1[95] = jj_gen;
2665       ;
2666     }
2667     jj_consume_token(SEMICOLON);
2668   }
2669
2670   static final private boolean jj_2_1(int xla) {
2671     jj_la = xla; jj_lastpos = jj_scanpos = token;
2672     boolean retval = !jj_3_1();
2673     jj_save(0, xla);
2674     return retval;
2675   }
2676
2677   static final private boolean jj_2_2(int xla) {
2678     jj_la = xla; jj_lastpos = jj_scanpos = token;
2679     boolean retval = !jj_3_2();
2680     jj_save(1, xla);
2681     return retval;
2682   }
2683
2684   static final private boolean jj_2_3(int xla) {
2685     jj_la = xla; jj_lastpos = jj_scanpos = token;
2686     boolean retval = !jj_3_3();
2687     jj_save(2, xla);
2688     return retval;
2689   }
2690
2691   static final private boolean jj_2_4(int xla) {
2692     jj_la = xla; jj_lastpos = jj_scanpos = token;
2693     boolean retval = !jj_3_4();
2694     jj_save(3, xla);
2695     return retval;
2696   }
2697
2698   static final private boolean jj_2_5(int xla) {
2699     jj_la = xla; jj_lastpos = jj_scanpos = token;
2700     boolean retval = !jj_3_5();
2701     jj_save(4, xla);
2702     return retval;
2703   }
2704
2705   static final private boolean jj_2_6(int xla) {
2706     jj_la = xla; jj_lastpos = jj_scanpos = token;
2707     boolean retval = !jj_3_6();
2708     jj_save(5, xla);
2709     return retval;
2710   }
2711
2712   static final private boolean jj_2_7(int xla) {
2713     jj_la = xla; jj_lastpos = jj_scanpos = token;
2714     boolean retval = !jj_3_7();
2715     jj_save(6, xla);
2716     return retval;
2717   }
2718
2719   static final private boolean jj_3R_43() {
2720     if (jj_scan_token(BOOL)) return true;
2721     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2722     return false;
2723   }
2724
2725   static final private boolean jj_3R_135() {
2726     Token xsp;
2727     xsp = jj_scanpos;
2728     if (jj_3R_137()) {
2729     jj_scanpos = xsp;
2730     if (jj_3R_138()) {
2731     jj_scanpos = xsp;
2732     if (jj_3R_139()) {
2733     jj_scanpos = xsp;
2734     if (jj_3R_140()) {
2735     jj_scanpos = xsp;
2736     if (jj_3R_141()) return true;
2737     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2738     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2739     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2740     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2741     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2742     return false;
2743   }
2744
2745   static final private boolean jj_3R_137() {
2746     if (jj_scan_token(BANG)) return true;
2747     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2748     if (jj_3R_119()) return true;
2749     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2750     return false;
2751   }
2752
2753   static final private boolean jj_3R_34() {
2754     Token xsp;
2755     xsp = jj_scanpos;
2756     if (jj_3R_42()) {
2757     jj_scanpos = xsp;
2758     if (jj_3R_43()) {
2759     jj_scanpos = xsp;
2760     if (jj_3R_44()) {
2761     jj_scanpos = xsp;
2762     if (jj_3R_45()) {
2763     jj_scanpos = xsp;
2764     if (jj_3R_46()) {
2765     jj_scanpos = xsp;
2766     if (jj_3R_47()) {
2767     jj_scanpos = xsp;
2768     if (jj_3R_48()) {
2769     jj_scanpos = xsp;
2770     if (jj_3R_49()) return true;
2771     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2772     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2773     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2774     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2775     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2776     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2777     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2778     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2779     return false;
2780   }
2781
2782   static final private boolean jj_3R_42() {
2783     if (jj_scan_token(STRING)) return true;
2784     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2785     return false;
2786   }
2787
2788   static final private boolean jj_3R_132() {
2789     if (jj_scan_token(MINUS)) return true;
2790     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2791     return false;
2792   }
2793
2794   static final private boolean jj_3R_134() {
2795     if (jj_scan_token(DECR)) return true;
2796     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2797     if (jj_3R_136()) return true;
2798     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2799     return false;
2800   }
2801
2802   static final private boolean jj_3R_53() {
2803     if (jj_scan_token(COMMA)) return true;
2804     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2805     if (jj_3R_52()) return true;
2806     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2807     return false;
2808   }
2809
2810   static final private boolean jj_3R_130() {
2811     if (jj_scan_token(REM)) return true;
2812     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2813     return false;
2814   }
2815
2816   static final private boolean jj_3R_133() {
2817     if (jj_scan_token(INCR)) return true;
2818     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2819     if (jj_3R_136()) return true;
2820     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2821     return false;
2822   }
2823
2824   static final private boolean jj_3R_127() {
2825     if (jj_3R_135()) return true;
2826     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2827     return false;
2828   }
2829
2830   static final private boolean jj_3R_126() {
2831     if (jj_3R_134()) return true;
2832     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2833     return false;
2834   }
2835
2836   static final private boolean jj_3R_125() {
2837     if (jj_3R_133()) return true;
2838     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2839     return false;
2840   }
2841
2842   static final private boolean jj_3R_129() {
2843     if (jj_scan_token(SLASH)) return true;
2844     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2845     return false;
2846   }
2847
2848   static final private boolean jj_3R_39() {
2849     if (jj_3R_52()) return true;
2850     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2851     Token xsp;
2852     while (true) {
2853       xsp = jj_scanpos;
2854       if (jj_3R_53()) { jj_scanpos = xsp; break; }
2855       if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2856     }
2857     return false;
2858   }
2859
2860   static final private boolean jj_3R_131() {
2861     if (jj_scan_token(PLUS)) return true;
2862     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2863     return false;
2864   }
2865
2866   static final private boolean jj_3R_124() {
2867     Token xsp;
2868     xsp = jj_scanpos;
2869     if (jj_3R_131()) {
2870     jj_scanpos = xsp;
2871     if (jj_3R_132()) return true;
2872     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2873     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2874     if (jj_3R_119()) return true;
2875     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2876     return false;
2877   }
2878
2879   static final private boolean jj_3R_119() {
2880     Token xsp;
2881     xsp = jj_scanpos;
2882     if (jj_3R_123()) {
2883     jj_scanpos = xsp;
2884     if (jj_3R_124()) {
2885     jj_scanpos = xsp;
2886     if (jj_3R_125()) {
2887     jj_scanpos = xsp;
2888     if (jj_3R_126()) {
2889     jj_scanpos = xsp;
2890     if (jj_3R_127()) return true;
2891     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2892     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2893     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2894     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2895     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2896     return false;
2897   }
2898
2899   static final private boolean jj_3R_123() {
2900     if (jj_scan_token(AT)) return true;
2901     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2902     if (jj_3R_119()) return true;
2903     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2904     return false;
2905   }
2906
2907   static final private boolean jj_3R_118() {
2908     if (jj_scan_token(RUNSIGNEDSHIFT)) return true;
2909     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2910     return false;
2911   }
2912
2913   static final private boolean jj_3R_122() {
2914     if (jj_scan_token(MINUS)) return true;
2915     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2916     return false;
2917   }
2918
2919   static final private boolean jj_3R_128() {
2920     if (jj_scan_token(STAR)) return true;
2921     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2922     return false;
2923   }
2924
2925   static final private boolean jj_3R_120() {
2926     Token xsp;
2927     xsp = jj_scanpos;
2928     if (jj_3R_128()) {
2929     jj_scanpos = xsp;
2930     if (jj_3R_129()) {
2931     jj_scanpos = xsp;
2932     if (jj_3R_130()) return true;
2933     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2934     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2935     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2936     if (jj_3R_119()) return true;
2937     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2938     return false;
2939   }
2940
2941   static final private boolean jj_3R_38() {
2942     if (jj_scan_token(IDENTIFIER)) return true;
2943     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2944     if (jj_scan_token(COLON)) return true;
2945     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2946     return false;
2947   }
2948
2949   static final private boolean jj_3R_113() {
2950     if (jj_scan_token(GE)) return true;
2951     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2952     return false;
2953   }
2954
2955   static final private boolean jj_3R_114() {
2956     if (jj_3R_119()) return true;
2957     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2958     Token xsp;
2959     while (true) {
2960       xsp = jj_scanpos;
2961       if (jj_3R_120()) { jj_scanpos = xsp; break; }
2962       if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2963     }
2964     return false;
2965   }
2966
2967   static final private boolean jj_3_2() {
2968     if (jj_scan_token(COMMA)) return true;
2969     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2970     if (jj_3R_33()) return true;
2971     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2972     return false;
2973   }
2974
2975   static final private boolean jj_3R_174() {
2976     if (jj_3R_33()) return true;
2977     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2978     Token xsp;
2979     while (true) {
2980       xsp = jj_scanpos;
2981       if (jj_3_2()) { jj_scanpos = xsp; break; }
2982       if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2983     }
2984     return false;
2985   }
2986
2987   static final private boolean jj_3R_117() {
2988     if (jj_scan_token(RSIGNEDSHIFT)) return true;
2989     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2990     return false;
2991   }
2992
2993   static final private boolean jj_3R_121() {
2994     if (jj_scan_token(PLUS)) return true;
2995     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2996     return false;
2997   }
2998
2999   static final private boolean jj_3R_115() {
3000     Token xsp;
3001     xsp = jj_scanpos;
3002     if (jj_3R_121()) {
3003     jj_scanpos = xsp;
3004     if (jj_3R_122()) return true;
3005     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3006     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3007     if (jj_3R_114()) return true;
3008     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3009     return false;
3010   }
3011
3012   static final private boolean jj_3R_112() {
3013     if (jj_scan_token(LE)) return true;
3014     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3015     return false;
3016   }
3017
3018   static final private boolean jj_3R_163() {
3019     if (jj_scan_token(LPAREN)) return true;
3020     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3021     Token xsp;
3022     xsp = jj_scanpos;
3023     if (jj_3R_174()) jj_scanpos = xsp;
3024     else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3025     if (jj_scan_token(RPAREN)) return true;
3026     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3027     return false;
3028   }
3029
3030   static final private boolean jj_3R_108() {
3031     if (jj_3R_114()) return true;
3032     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3033     Token xsp;
3034     while (true) {
3035       xsp = jj_scanpos;
3036       if (jj_3R_115()) { jj_scanpos = xsp; break; }
3037       if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3038     }
3039     return false;
3040   }
3041
3042   static final private boolean jj_3R_175() {
3043     if (jj_scan_token(ARRAYASSIGN)) return true;
3044     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3045     if (jj_3R_35()) return true;
3046     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3047     return false;
3048   }
3049
3050   static final private boolean jj_3R_33() {
3051     if (jj_3R_35()) return true;
3052     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3053     Token xsp;
3054     xsp = jj_scanpos;
3055     if (jj_3R_175()) jj_scanpos = xsp;
3056     else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3057     return false;
3058   }
3059
3060   static final private boolean jj_3R_56() {
3061     if (jj_scan_token(PRINT)) return true;
3062     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3063     if (jj_3R_35()) return true;
3064     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3065     return false;
3066   }
3067
3068   static final private boolean jj_3R_116() {
3069     if (jj_scan_token(LSHIFT)) return true;
3070     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3071     return false;
3072   }
3073
3074   static final private boolean jj_3R_97() {
3075     if (jj_scan_token(LBRACE)) return true;
3076     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3077     if (jj_3R_35()) return true;
3078     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3079     if (jj_scan_token(RBRACE)) return true;
3080     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3081     return false;
3082   }
3083
3084   static final private boolean jj_3R_109() {
3085     Token xsp;
3086     xsp = jj_scanpos;
3087     if (jj_3R_116()) {
3088     jj_scanpos = xsp;
3089     if (jj_3R_117()) {
3090     jj_scanpos = xsp;
3091     if (jj_3R_118()) return true;
3092     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3093     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3094     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3095     if (jj_3R_108()) return true;
3096     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3097     return false;
3098   }
3099
3100   static final private boolean jj_3R_111() {
3101     if (jj_scan_token(GT)) return true;
3102     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3103     return false;
3104   }
3105
3106   static final private boolean jj_3R_104() {
3107     if (jj_3R_108()) return true;
3108     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3109     Token xsp;
3110     while (true) {
3111       xsp = jj_scanpos;
3112       if (jj_3R_109()) { jj_scanpos = xsp; break; }
3113       if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3114     }
3115     return false;
3116   }
3117
3118   static final private boolean jj_3R_68() {
3119     if (jj_3R_35()) return true;
3120     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3121     return false;
3122   }
3123
3124   static final private boolean jj_3R_63() {
3125     if (jj_scan_token(DOLLAR)) return true;
3126     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3127     if (jj_3R_54()) return true;
3128     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3129     return false;
3130   }
3131
3132   static final private boolean jj_3R_110() {
3133     if (jj_scan_token(LT)) return true;
3134     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3135     return false;
3136   }
3137
3138   static final private boolean jj_3R_105() {
3139     Token xsp;
3140     xsp = jj_scanpos;
3141     if (jj_3R_110()) {
3142     jj_scanpos = xsp;
3143     if (jj_3R_111()) {
3144     jj_scanpos = xsp;
3145     if (jj_3R_112()) {
3146     jj_scanpos = xsp;
3147     if (jj_3R_113()) return true;
3148     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3149     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3150     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3151     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3152     if (jj_3R_104()) return true;
3153     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3154     return false;
3155   }
3156
3157   static final private boolean jj_3R_107() {
3158     if (jj_scan_token(NE)) return true;
3159     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3160     return false;
3161   }
3162
3163   static final private boolean jj_3R_90() {
3164     if (jj_scan_token(LBRACE)) return true;
3165     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3166     if (jj_3R_35()) return true;
3167     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3168     if (jj_scan_token(RBRACE)) return true;
3169     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3170     return false;
3171   }
3172
3173   static final private boolean jj_3R_62() {
3174     if (jj_scan_token(IDENTIFIER)) return true;
3175     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3176     Token xsp;
3177     xsp = jj_scanpos;
3178     if (jj_3R_97()) jj_scanpos = xsp;
3179     else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3180     return false;
3181   }
3182
3183   static final private boolean jj_3R_102() {
3184     if (jj_3R_104()) return true;
3185     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3186     Token xsp;
3187     while (true) {
3188       xsp = jj_scanpos;
3189       if (jj_3R_105()) { jj_scanpos = xsp; break; }
3190       if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3191     }
3192     return false;
3193   }
3194
3195   static final private boolean jj_3R_61() {
3196     if (jj_scan_token(LBRACE)) return true;
3197     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3198     if (jj_3R_35()) return true;
3199     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3200     if (jj_scan_token(RBRACE)) return true;
3201     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3202     return false;
3203   }
3204
3205   static final private boolean jj_3R_54() {
3206     Token xsp;
3207     xsp = jj_scanpos;
3208     if (jj_3R_61()) {
3209     jj_scanpos = xsp;
3210     if (jj_3R_62()) {
3211     jj_scanpos = xsp;
3212     if (jj_3R_63()) return true;
3213     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3214     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3215     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3216     return false;
3217   }
3218
3219   static final private boolean jj_3R_37() {
3220     if (jj_scan_token(127)) return true;
3221     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3222     return false;
3223   }
3224
3225   static final private boolean jj_3R_85() {
3226     if (jj_scan_token(DOLLAR)) return true;
3227     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3228     if (jj_3R_54()) return true;
3229     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3230     return false;
3231   }
3232
3233   static final private boolean jj_3R_106() {
3234     if (jj_scan_token(EQ)) return true;
3235     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3236     return false;
3237   }
3238
3239   static final private boolean jj_3R_103() {
3240     Token xsp;
3241     xsp = jj_scanpos;
3242     if (jj_3R_106()) {
3243     jj_scanpos = xsp;
3244     if (jj_3R_107()) return true;
3245     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3246     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3247     if (jj_3R_102()) return true;
3248     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3249     return false;
3250   }
3251
3252   static final private boolean jj_3R_36() {
3253     if (jj_scan_token(SEMICOLON)) return true;
3254     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3255     return false;
3256   }
3257
3258   static final private boolean jj_3R_84() {
3259     if (jj_scan_token(DOLLAR_ID)) return true;
3260     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3261     Token xsp;
3262     xsp = jj_scanpos;
3263     if (jj_3R_90()) jj_scanpos = xsp;
3264     else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3265     return false;
3266   }
3267
3268   static final private boolean jj_3R_67() {
3269     Token xsp;
3270     xsp = jj_scanpos;
3271     if (jj_3R_84()) {
3272     jj_scanpos = xsp;
3273     if (jj_3R_85()) return true;
3274     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3275     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3276     return false;
3277   }
3278
3279   static final private boolean jj_3R_100() {
3280     if (jj_3R_102()) return true;
3281     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3282     Token xsp;
3283     while (true) {
3284       xsp = jj_scanpos;
3285       if (jj_3R_103()) { jj_scanpos = xsp; break; }
3286       if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3287     }
3288     return false;
3289   }
3290
3291   static final private boolean jj_3_1() {
3292     if (jj_3R_32()) return true;
3293     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3294     return false;
3295   }
3296
3297   static final private boolean jj_3_6() {
3298     if (jj_3R_38()) return true;
3299     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3300     return false;
3301   }
3302
3303   static final private boolean jj_3R_59() {
3304     if (jj_3R_67()) return true;
3305     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3306     Token xsp;
3307     while (true) {
3308       xsp = jj_scanpos;
3309       if (jj_3_1()) { jj_scanpos = xsp; break; }
3310       if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3311     }
3312     return false;
3313   }
3314
3315   static final private boolean jj_3_5() {
3316     if (jj_3R_35()) return true;
3317     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3318     Token xsp;
3319     xsp = jj_scanpos;
3320     if (jj_3R_36()) {
3321     jj_scanpos = xsp;
3322     if (jj_3R_37()) return true;
3323     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3324     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3325     return false;
3326   }
3327
3328   static final private boolean jj_3R_101() {
3329     if (jj_scan_token(BIT_AND)) return true;
3330     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3331     if (jj_3R_100()) return true;
3332     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3333     return false;
3334   }
3335
3336   static final private boolean jj_3R_60() {
3337     if (jj_scan_token(ASSIGN)) return true;
3338     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3339     if (jj_3R_68()) return true;
3340     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3341     return false;
3342   }
3343
3344   static final private boolean jj_3R_98() {
3345     if (jj_3R_100()) return true;
3346     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3347     Token xsp;
3348     while (true) {
3349       xsp = jj_scanpos;
3350       if (jj_3R_101()) { jj_scanpos = xsp; break; }
3351       if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3352     }
3353     return false;
3354   }
3355
3356   static final private boolean jj_3R_52() {
3357     if (jj_3R_59()) return true;
3358     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3359     Token xsp;
3360     xsp = jj_scanpos;
3361     if (jj_3R_60()) jj_scanpos = xsp;
3362     else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3363     return false;
3364   }
3365
3366   static final private boolean jj_3R_178() {
3367     if (jj_scan_token(COMMA)) return true;
3368     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3369     if (jj_3R_35()) return true;
3370     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3371     return false;
3372   }
3373
3374   static final private boolean jj_3R_177() {
3375     if (jj_3R_35()) return true;
3376     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3377     Token xsp;
3378     while (true) {
3379       xsp = jj_scanpos;
3380       if (jj_3R_178()) { jj_scanpos = xsp; break; }
3381       if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3382     }
3383     return false;
3384   }
3385
3386   static final private boolean jj_3R_99() {
3387     if (jj_scan_token(XOR)) return true;
3388     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3389     if (jj_3R_98()) return true;
3390     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3391     return false;
3392   }
3393
3394   static final private boolean jj_3R_95() {
3395     if (jj_3R_98()) return true;
3396     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3397     Token xsp;
3398     while (true) {
3399       xsp = jj_scanpos;
3400       if (jj_3R_99()) { jj_scanpos = xsp; break; }
3401       if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3402     }
3403     return false;
3404   }
3405
3406   static final private boolean jj_3R_176() {
3407     if (jj_3R_177()) return true;
3408     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3409     return false;
3410   }
3411
3412   static final private boolean jj_3R_173() {
3413     if (jj_scan_token(LPAREN)) return true;
3414     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3415     Token xsp;
3416     xsp = jj_scanpos;
3417     if (jj_3R_176()) jj_scanpos = xsp;
3418     else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3419     if (jj_scan_token(RPAREN)) return true;
3420     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3421     return false;
3422   }
3423
3424   static final private boolean jj_3R_96() {
3425     if (jj_scan_token(BIT_OR)) return true;
3426     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3427     if (jj_3R_95()) return true;
3428     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3429     return false;
3430   }
3431
3432   static final private boolean jj_3R_91() {
3433     if (jj_3R_95()) return true;
3434     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3435     Token xsp;
3436     while (true) {
3437       xsp = jj_scanpos;
3438       if (jj_3R_96()) { jj_scanpos = xsp; break; }
3439       if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3440     }
3441     return false;
3442   }
3443
3444   static final private boolean jj_3R_160() {
3445     if (jj_scan_token(NULL)) return true;
3446     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3447     return false;
3448   }
3449
3450   static final private boolean jj_3R_165() {
3451     if (jj_scan_token(FALSE)) return true;
3452     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3453     return false;
3454   }
3455
3456   static final private boolean jj_3R_159() {
3457     Token xsp;
3458     xsp = jj_scanpos;
3459     if (jj_3R_164()) {
3460     jj_scanpos = xsp;
3461     if (jj_3R_165()) return true;
3462     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3463     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3464     return false;
3465   }
3466
3467   static final private boolean jj_3R_164() {
3468     if (jj_scan_token(TRUE)) return true;
3469     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3470     return false;
3471   }
3472
3473   static final private boolean jj_3R_153() {
3474     if (jj_3R_160()) return true;
3475     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3476     return false;
3477   }
3478
3479   static final private boolean jj_3R_94() {
3480     if (jj_scan_token(_ANDL)) return true;
3481     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3482     return false;
3483   }
3484
3485   static final private boolean jj_3R_92() {
3486     if (jj_scan_token(DOT)) return true;
3487     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3488     if (jj_3R_91()) return true;
3489     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3490     return false;
3491   }
3492
3493   static final private boolean jj_3R_152() {
3494     if (jj_3R_159()) return true;
3495     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3496     return false;
3497   }
3498
3499   static final private boolean jj_3R_86() {
3500     if (jj_3R_91()) return true;
3501     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3502     Token xsp;
3503     while (true) {
3504       xsp = jj_scanpos;
3505       if (jj_3R_92()) { jj_scanpos = xsp; break; }
3506       if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3507     }
3508     return false;
3509   }
3510
3511   static final private boolean jj_3R_151() {
3512     if (jj_scan_token(STRING_LITERAL)) return true;
3513     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3514     return false;
3515   }
3516
3517   static final private boolean jj_3R_150() {
3518     if (jj_scan_token(FLOATING_POINT_LITERAL)) return true;
3519     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3520     return false;
3521   }
3522
3523   static final private boolean jj_3R_146() {
3524     Token xsp;
3525     xsp = jj_scanpos;
3526     if (jj_3R_149()) {
3527     jj_scanpos = xsp;
3528     if (jj_3R_150()) {
3529     jj_scanpos = xsp;
3530     if (jj_3R_151()) {
3531     jj_scanpos = xsp;
3532     if (jj_3R_152()) {
3533     jj_scanpos = xsp;
3534     if (jj_3R_153()) return true;
3535     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3536     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3537     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3538     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3539     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3540     return false;
3541   }
3542
3543   static final private boolean jj_3R_149() {
3544     if (jj_scan_token(INTEGER_LITERAL)) return true;
3545     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3546     return false;
3547   }
3548
3549   static final private boolean jj_3R_55() {
3550     if (jj_3R_35()) return true;
3551     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3552     return false;
3553   }
3554
3555   static final private boolean jj_3R_93() {
3556     if (jj_scan_token(SC_AND)) return true;
3557     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3558     return false;
3559   }
3560
3561   static final private boolean jj_3R_89() {
3562     if (jj_scan_token(_ORL)) return true;
3563     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3564     return false;
3565   }
3566
3567   static final private boolean jj_3R_87() {
3568     Token xsp;
3569     xsp = jj_scanpos;
3570     if (jj_3R_93()) {
3571     jj_scanpos = xsp;
3572     if (jj_3R_94()) return true;
3573     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3574     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3575     if (jj_3R_86()) return true;
3576     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3577     return false;
3578   }
3579
3580   static final private boolean jj_3R_69() {
3581     if (jj_3R_86()) return true;
3582     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3583     Token xsp;
3584     while (true) {
3585       xsp = jj_scanpos;
3586       if (jj_3R_87()) { jj_scanpos = xsp; break; }
3587       if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3588     }
3589     return false;
3590   }
3591
3592   static final private boolean jj_3R_41() {
3593     if (jj_scan_token(LBRACKET)) return true;
3594     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3595     Token xsp;
3596     xsp = jj_scanpos;
3597     if (jj_3R_55()) jj_scanpos = xsp;
3598     else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3599     if (jj_scan_token(RBRACKET)) return true;
3600     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3601     return false;
3602   }
3603
3604   static final private boolean jj_3R_65() {
3605     if (jj_scan_token(HOOK)) return true;
3606     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3607     if (jj_3R_35()) return true;
3608     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3609     if (jj_scan_token(COLON)) return true;
3610     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3611     if (jj_3R_57()) return true;
3612     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3613     return false;
3614   }
3615
3616   static final private boolean jj_3R_40() {
3617     if (jj_scan_token(CLASSACCESS)) return true;
3618     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3619     if (jj_3R_54()) return true;
3620     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3621     return false;
3622   }
3623
3624   static final private boolean jj_3R_32() {
3625     Token xsp;
3626     xsp = jj_scanpos;
3627     if (jj_3R_40()) {
3628     jj_scanpos = xsp;
3629     if (jj_3R_41()) return true;
3630     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3631     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3632     return false;
3633   }
3634
3635   static final private boolean jj_3R_169() {
3636     if (jj_3R_32()) return true;
3637     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3638     return false;
3639   }
3640
3641   static final private boolean jj_3R_88() {
3642     if (jj_scan_token(SC_OR)) return true;
3643     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3644     return false;
3645   }
3646
3647   static final private boolean jj_3R_70() {
3648     Token xsp;
3649     xsp = jj_scanpos;
3650     if (jj_3R_88()) {
3651     jj_scanpos = xsp;
3652     if (jj_3R_89()) return true;
3653     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3654     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3655     if (jj_3R_69()) return true;
3656     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3657     return false;
3658   }
3659
3660   static final private boolean jj_3R_168() {
3661     if (jj_3R_173()) return true;
3662     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3663     return false;
3664   }
3665
3666   static final private boolean jj_3R_166() {
3667     Token xsp;
3668     xsp = jj_scanpos;
3669     if (jj_3R_168()) {
3670     jj_scanpos = xsp;
3671     if (jj_3R_169()) return true;
3672     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3673     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3674     return false;
3675   }
3676
3677   static final private boolean jj_3R_64() {
3678     if (jj_3R_69()) return true;
3679     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3680     Token xsp;
3681     while (true) {
3682       xsp = jj_scanpos;
3683       if (jj_3R_70()) { jj_scanpos = xsp; break; }
3684       if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3685     }
3686     return false;
3687   }
3688
3689   static final private boolean jj_3R_172() {
3690     if (jj_3R_59()) return true;
3691     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3692     return false;
3693   }
3694
3695   static final private boolean jj_3R_171() {
3696     if (jj_scan_token(IDENTIFIER)) return true;
3697     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3698     return false;
3699   }
3700
3701   static final private boolean jj_3R_167() {
3702     Token xsp;
3703     xsp = jj_scanpos;
3704     if (jj_3R_171()) {
3705     jj_scanpos = xsp;
3706     if (jj_3R_172()) return true;
3707     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3708     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3709     return false;
3710   }
3711
3712   static final private boolean jj_3_7() {
3713     if (jj_3R_39()) return true;
3714     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3715     return false;
3716   }
3717
3718   static final private boolean jj_3R_156() {
3719     if (jj_3R_59()) return true;
3720     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3721     return false;
3722   }
3723
3724   static final private boolean jj_3R_57() {
3725     if (jj_3R_64()) return true;
3726     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3727     Token xsp;
3728     xsp = jj_scanpos;
3729     if (jj_3R_65()) jj_scanpos = xsp;
3730     else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3731     return false;
3732   }
3733
3734   static final private boolean jj_3R_158() {
3735     if (jj_scan_token(DECR)) return true;
3736     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3737     return false;
3738   }
3739
3740   static final private boolean jj_3R_161() {
3741     if (jj_scan_token(BIT_AND)) return true;
3742     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3743     return false;
3744   }
3745
3746   static final private boolean jj_3R_155() {
3747     Token xsp;
3748     xsp = jj_scanpos;
3749     if (jj_3R_161()) jj_scanpos = xsp;
3750     else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3751     if (jj_scan_token(NEW)) return true;
3752     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3753     if (jj_3R_167()) return true;
3754     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3755     return false;
3756   }
3757
3758   static final private boolean jj_3R_147() {
3759     Token xsp;
3760     xsp = jj_scanpos;
3761     if (jj_3R_154()) {
3762     jj_scanpos = xsp;
3763     if (jj_3R_155()) {
3764     jj_scanpos = xsp;
3765     if (jj_3R_156()) return true;
3766     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3767     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3768     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3769     return false;
3770   }
3771
3772   static final private boolean jj_3R_154() {
3773     if (jj_scan_token(IDENTIFIER)) return true;
3774     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3775     return false;
3776   }
3777
3778   static final private boolean jj_3R_83() {
3779     if (jj_scan_token(DOTASSIGN)) return true;
3780     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3781     return false;
3782   }
3783
3784   static final private boolean jj_3R_82() {
3785     if (jj_scan_token(ORASSIGN)) return true;
3786     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3787     return false;
3788   }
3789
3790   static final private boolean jj_3R_81() {
3791     if (jj_scan_token(XORASSIGN)) return true;
3792     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3793     return false;
3794   }
3795
3796   static final private boolean jj_3R_80() {
3797     if (jj_scan_token(ANDASSIGN)) return true;
3798     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3799     return false;
3800   }
3801
3802   static final private boolean jj_3R_79() {
3803     if (jj_scan_token(RUNSIGNEDSHIFTASSIGN)) return true;
3804     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3805     return false;
3806   }
3807
3808   static final private boolean jj_3R_143() {
3809     if (jj_scan_token(ARRAY)) return true;
3810     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3811     if (jj_3R_163()) return true;
3812     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3813     return false;
3814   }
3815
3816   static final private boolean jj_3R_78() {
3817     if (jj_scan_token(RSIGNEDSHIFTASSIGN)) return true;
3818     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3819     return false;
3820   }
3821
3822   static final private boolean jj_3R_77() {
3823     if (jj_scan_token(LSHIFTASSIGN)) return true;
3824     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3825     return false;
3826   }
3827
3828   static final private boolean jj_3R_148() {
3829     Token xsp;
3830     xsp = jj_scanpos;
3831     if (jj_3R_157()) {
3832     jj_scanpos = xsp;
3833     if (jj_3R_158()) return true;
3834     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3835     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3836     return false;
3837   }
3838
3839   static final private boolean jj_3R_157() {
3840     if (jj_scan_token(INCR)) return true;
3841     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3842     return false;
3843   }
3844
3845   static final private boolean jj_3R_76() {
3846     if (jj_scan_token(MINUSASSIGN)) return true;
3847     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3848     return false;
3849   }
3850
3851   static final private boolean jj_3R_162() {
3852     if (jj_3R_166()) return true;
3853     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3854     return false;
3855   }
3856
3857   static final private boolean jj_3R_75() {
3858     if (jj_scan_token(PLUSASSIGN)) return true;
3859     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3860     return false;
3861   }
3862
3863   static final private boolean jj_3R_142() {
3864     if (jj_3R_147()) return true;
3865     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3866     Token xsp;
3867     while (true) {
3868       xsp = jj_scanpos;
3869       if (jj_3R_162()) { jj_scanpos = xsp; break; }
3870       if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3871     }
3872     return false;
3873   }
3874
3875   static final private boolean jj_3R_74() {
3876     if (jj_scan_token(REMASSIGN)) return true;
3877     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3878     return false;
3879   }
3880
3881   static final private boolean jj_3R_73() {
3882     if (jj_scan_token(SLASHASSIGN)) return true;
3883     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3884     return false;
3885   }
3886
3887   static final private boolean jj_3R_170() {
3888     if (jj_3R_166()) return true;
3889     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3890     return false;
3891   }
3892
3893   static final private boolean jj_3R_72() {
3894     if (jj_scan_token(STARASSIGN)) return true;
3895     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3896     return false;
3897   }
3898
3899   static final private boolean jj_3R_71() {
3900     if (jj_scan_token(ASSIGN)) return true;
3901     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3902     return false;
3903   }
3904
3905   static final private boolean jj_3R_66() {
3906     Token xsp;
3907     xsp = jj_scanpos;
3908     if (jj_3R_71()) {
3909     jj_scanpos = xsp;
3910     if (jj_3R_72()) {
3911     jj_scanpos = xsp;
3912     if (jj_3R_73()) {
3913     jj_scanpos = xsp;
3914     if (jj_3R_74()) {
3915     jj_scanpos = xsp;
3916     if (jj_3R_75()) {
3917     jj_scanpos = xsp;
3918     if (jj_3R_76()) {
3919     jj_scanpos = xsp;
3920     if (jj_3R_77()) {
3921     jj_scanpos = xsp;
3922     if (jj_3R_78()) {
3923     jj_scanpos = xsp;
3924     if (jj_3R_79()) {
3925     jj_scanpos = xsp;
3926     if (jj_3R_80()) {
3927     jj_scanpos = xsp;
3928     if (jj_3R_81()) {
3929     jj_scanpos = xsp;
3930     if (jj_3R_82()) {
3931     jj_scanpos = xsp;
3932     if (jj_3R_83()) return true;
3933     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3934     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3935     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3936     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3937     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3938     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3939     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3940     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3941     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3942     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3943     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3944     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3945     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3946     return false;
3947   }
3948
3949   static final private boolean jj_3_4() {
3950     if (jj_scan_token(IDENTIFIER)) return true;
3951     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3952     if (jj_scan_token(STATICCLASSACCESS)) return true;
3953     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3954     if (jj_3R_167()) return true;
3955     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3956     Token xsp;
3957     while (true) {
3958       xsp = jj_scanpos;
3959       if (jj_3R_170()) { jj_scanpos = xsp; break; }
3960       if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3961     }
3962     return false;
3963   }
3964
3965   static final private boolean jj_3R_136() {
3966     Token xsp;
3967     xsp = jj_scanpos;
3968     if (jj_3_4()) {
3969     jj_scanpos = xsp;
3970     if (jj_3R_142()) {
3971     jj_scanpos = xsp;
3972     if (jj_3R_143()) return true;
3973     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3974     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3975     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3976     return false;
3977   }
3978
3979   static final private boolean jj_3R_58() {
3980     if (jj_3R_66()) return true;
3981     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3982     if (jj_3R_35()) return true;
3983     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3984     return false;
3985   }
3986
3987   static final private boolean jj_3R_145() {
3988     if (jj_3R_136()) return true;
3989     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3990     Token xsp;
3991     xsp = jj_scanpos;
3992     if (jj_3R_148()) jj_scanpos = xsp;
3993     else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3994     return false;
3995   }
3996
3997   static final private boolean jj_3R_51() {
3998     if (jj_3R_57()) return true;
3999     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4000     Token xsp;
4001     xsp = jj_scanpos;
4002     if (jj_3R_58()) jj_scanpos = xsp;
4003     else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4004     return false;
4005   }
4006
4007   static final private boolean jj_3R_35() {
4008     Token xsp;
4009     xsp = jj_scanpos;
4010     if (jj_3R_50()) {
4011     jj_scanpos = xsp;
4012     if (jj_3R_51()) return true;
4013     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4014     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4015     return false;
4016   }
4017
4018   static final private boolean jj_3R_50() {
4019     if (jj_3R_56()) return true;
4020     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4021     return false;
4022   }
4023
4024   static final private boolean jj_3R_144() {
4025     if (jj_scan_token(LPAREN)) return true;
4026     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4027     if (jj_3R_34()) return true;
4028     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4029     if (jj_scan_token(RPAREN)) return true;
4030     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4031     if (jj_3R_119()) return true;
4032     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4033     return false;
4034   }
4035
4036   static final private boolean jj_3R_49() {
4037     if (jj_scan_token(INTEGER)) return true;
4038     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4039     return false;
4040   }
4041
4042   static final private boolean jj_3R_48() {
4043     if (jj_scan_token(INT)) return true;
4044     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4045     return false;
4046   }
4047
4048   static final private boolean jj_3_3() {
4049     if (jj_scan_token(LPAREN)) return true;
4050     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4051     if (jj_3R_34()) return true;
4052     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4053     if (jj_scan_token(RPAREN)) return true;
4054     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4055     return false;
4056   }
4057
4058   static final private boolean jj_3R_141() {
4059     if (jj_scan_token(LPAREN)) return true;
4060     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4061     if (jj_3R_35()) return true;
4062     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4063     if (jj_scan_token(RPAREN)) return true;
4064     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4065     return false;
4066   }
4067
4068   static final private boolean jj_3R_47() {
4069     if (jj_scan_token(FLOAT)) return true;
4070     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4071     return false;
4072   }
4073
4074   static final private boolean jj_3R_140() {
4075     if (jj_3R_146()) return true;
4076     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4077     return false;
4078   }
4079
4080   static final private boolean jj_3R_46() {
4081     if (jj_scan_token(DOUBLE)) return true;
4082     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4083     return false;
4084   }
4085
4086   static final private boolean jj_3R_139() {
4087     if (jj_3R_145()) return true;
4088     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4089     return false;
4090   }
4091
4092   static final private boolean jj_3R_45() {
4093     if (jj_scan_token(REAL)) return true;
4094     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4095     return false;
4096   }
4097
4098   static final private boolean jj_3R_44() {
4099     if (jj_scan_token(BOOLEAN)) return true;
4100     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4101     return false;
4102   }
4103
4104   static final private boolean jj_3R_138() {
4105     if (jj_3R_144()) return true;
4106     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4107     return false;
4108   }
4109
4110   static private boolean jj_initialized_once = false;
4111   static public PHPParserTokenManager token_source;
4112   static SimpleCharStream jj_input_stream;
4113   static public Token token, jj_nt;
4114   static private int jj_ntk;
4115   static private Token jj_scanpos, jj_lastpos;
4116   static private int jj_la;
4117   static public boolean lookingAhead = false;
4118   static private boolean jj_semLA;
4119   static private int jj_gen;
4120   static final private int[] jj_la1 = new int[96];
4121   static final private int[] jj_la1_0 = {0x2,0x7fcb0000,0x0,0x60000,0x60000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xc00000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xc00000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x400000,0x0,0x400000,0x0,0x0,0x80000000,0x80000000,0x400000,0x0,0x0,0x0,0x80000000,0xc00000,0x80000000,0x0,0x0,0xc00000,0x0,0x0,0x7f480000,0x0,0x0,0x0,0x0,0x1e000000,0x0,0x0,0x0,0x0,0x0,0x0,0x7fcb0000,0x7fcb0000,0x0,0x0,0x0,0x400000,0x0,0x7fcb0000,0x0,0x100000,0x200000,0x7fc80000,0x0,0x7fc80000,0x0,0x400000,0xc00000,0x400000,0x400000,0x0,0x0,0x0,0xc00000,};
4122   static final private int[] jj_la1_1 = {0x0,0xd76a4,0x100,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x2,0x43200,0x0,0x0,0x0,0x0,0x0,0x3fa00000,0x0,0x43200,0x0,0x0,0x40000000,0x40000000,0x80000000,0x80000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x43200,0x0,0x43200,0x0,0x0,0x0,0x0,0x1000,0x0,0x1000,0x0,0x0,0x43200,0x0,0x42200,0x40200,0x43200,0x0,0x0,0x954a4,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xd76a4,0xd76a4,0x0,0x0,0x0,0x1000,0x48,0xd76a4,0x48,0x0,0x0,0xd76a4,0x0,0xd76a4,0x0,0x1000,0x43200,0x1000,0x1000,0x0,0x0,0x0,0x43200,};
4123   static final private int[] jj_la1_2 = {0x0,0x11914451,0x0,0x0,0x0,0x200000,0x2000000,0x10000,0x1000000,0x10000,0x1010400,0x0,0x11804451,0x110000,0x0,0x200000,0x1000000,0x0,0x0,0x2000000,0x11804451,0x2000000,0x20000000,0x0,0x0,0x0,0x0,0x400000,0x0,0x0,0x0,0x80000000,0x80000000,0xc000000,0xc000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x11804451,0x10000000,0x1004451,0x0,0x0,0x44000,0x44000,0x1000400,0x0,0x1000400,0x1000400,0x44000,0x11804451,0x40000,0x51,0x0,0x11804451,0x200000,0x100000,0x1110400,0x100000,0x100000,0x100000,0x100000,0x0,0x200000,0x100000,0x200000,0x100000,0x200000,0x100000,0x11914451,0x11914451,0x200000,0x2000000,0x2000000,0x1000400,0x0,0x11914451,0x0,0x0,0x0,0x11914451,0x100000,0x51914451,0x100000,0x1000400,0x11804451,0x1000400,0x1000400,0x200000,0x400,0x400,0x11804451,};
4124   static final private int[] jj_la1_3 = {0x0,0x400009e0,0x0,0x0,0x0,0x0,0x0,0x0,0x40000000,0x0,0x0,0x0,0x400009e0,0x0,0x800,0x0,0x40000800,0x800,0x0,0x3ffc0000,0x400009e0,0x3ffc0000,0x0,0x8,0x8,0x10,0x10,0x0,0x1000,0x2000,0x800,0x4,0x4,0x3,0x3,0x38000,0x38000,0x180,0x180,0x4600,0x4600,0x180,0x400009e0,0x0,0x40000800,0x60,0x60,0x0,0x0,0x40000800,0x800,0x40000800,0x40000000,0x0,0x400009e0,0x0,0x0,0x0,0x400009e0,0x0,0x80000000,0x40000860,0x80000000,0x80000000,0x80000000,0x80000000,0x0,0x0,0x80000000,0x0,0x80000000,0x0,0x80000000,0x400009e0,0x400009e0,0x0,0x3ffc0060,0x3ffc0060,0x40000860,0x0,0x400009e0,0x0,0x0,0x0,0x400009e0,0x80000000,0x400009e0,0x80000000,0x40000860,0x400009e0,0x40000860,0x40000860,0x0,0x0,0x0,0x400009e0,};
4125   static final private JJCalls[] jj_2_rtns = new JJCalls[7];
4126   static private boolean jj_rescan = false;
4127   static private int jj_gc = 0;
4128
4129   public PHPParser(java.io.InputStream stream) {
4130     if (jj_initialized_once) {
4131       System.out.println("ERROR: Second call to constructor of static parser.  You must");
4132       System.out.println("       either use ReInit() or set the JavaCC option STATIC to false");
4133       System.out.println("       during parser generation.");
4134       throw new Error();
4135     }
4136     jj_initialized_once = true;
4137     jj_input_stream = new SimpleCharStream(stream, 1, 1);
4138     token_source = new PHPParserTokenManager(jj_input_stream);
4139     token = new Token();
4140     jj_ntk = -1;
4141     jj_gen = 0;
4142     for (int i = 0; i < 96; i++) jj_la1[i] = -1;
4143     for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
4144   }
4145
4146   static public void ReInit(java.io.InputStream stream) {
4147     jj_input_stream.ReInit(stream, 1, 1);
4148     token_source.ReInit(jj_input_stream);
4149     token = new Token();
4150     jj_ntk = -1;
4151     jj_gen = 0;
4152     for (int i = 0; i < 96; i++) jj_la1[i] = -1;
4153     for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
4154   }
4155
4156   public PHPParser(java.io.Reader stream) {
4157     if (jj_initialized_once) {
4158       System.out.println("ERROR: Second call to constructor of static parser.  You must");
4159       System.out.println("       either use ReInit() or set the JavaCC option STATIC to false");
4160       System.out.println("       during parser generation.");
4161       throw new Error();
4162     }
4163     jj_initialized_once = true;
4164     jj_input_stream = new SimpleCharStream(stream, 1, 1);
4165     token_source = new PHPParserTokenManager(jj_input_stream);
4166     token = new Token();
4167     jj_ntk = -1;
4168     jj_gen = 0;
4169     for (int i = 0; i < 96; i++) jj_la1[i] = -1;
4170     for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
4171   }
4172
4173   static public void ReInit(java.io.Reader stream) {
4174     jj_input_stream.ReInit(stream, 1, 1);
4175     token_source.ReInit(jj_input_stream);
4176     token = new Token();
4177     jj_ntk = -1;
4178     jj_gen = 0;
4179     for (int i = 0; i < 96; i++) jj_la1[i] = -1;
4180     for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
4181   }
4182
4183   public PHPParser(PHPParserTokenManager tm) {
4184     if (jj_initialized_once) {
4185       System.out.println("ERROR: Second call to constructor of static parser.  You must");
4186       System.out.println("       either use ReInit() or set the JavaCC option STATIC to false");
4187       System.out.println("       during parser generation.");
4188       throw new Error();
4189     }
4190     jj_initialized_once = true;
4191     token_source = tm;
4192     token = new Token();
4193     jj_ntk = -1;
4194     jj_gen = 0;
4195     for (int i = 0; i < 96; i++) jj_la1[i] = -1;
4196     for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
4197   }
4198
4199   public void ReInit(PHPParserTokenManager tm) {
4200     token_source = tm;
4201     token = new Token();
4202     jj_ntk = -1;
4203     jj_gen = 0;
4204     for (int i = 0; i < 96; i++) jj_la1[i] = -1;
4205     for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
4206   }
4207
4208   static final private Token jj_consume_token(int kind) throws ParseException {
4209     Token oldToken;
4210     if ((oldToken = token).next != null) token = token.next;
4211     else token = token.next = token_source.getNextToken();
4212     jj_ntk = -1;
4213     if (token.kind == kind) {
4214       jj_gen++;
4215       if (++jj_gc > 100) {
4216         jj_gc = 0;
4217         for (int i = 0; i < jj_2_rtns.length; i++) {
4218           JJCalls c = jj_2_rtns[i];
4219           while (c != null) {
4220             if (c.gen < jj_gen) c.first = null;
4221             c = c.next;
4222           }
4223         }
4224       }
4225       return token;
4226     }
4227     token = oldToken;
4228     jj_kind = kind;
4229     throw generateParseException();
4230   }
4231
4232   static final private boolean jj_scan_token(int kind) {
4233     if (jj_scanpos == jj_lastpos) {
4234       jj_la--;
4235       if (jj_scanpos.next == null) {
4236         jj_lastpos = jj_scanpos = jj_scanpos.next = token_source.getNextToken();
4237       } else {
4238         jj_lastpos = jj_scanpos = jj_scanpos.next;
4239       }
4240     } else {
4241       jj_scanpos = jj_scanpos.next;
4242     }
4243     if (jj_rescan) {
4244       int i = 0; Token tok = token;
4245       while (tok != null && tok != jj_scanpos) { i++; tok = tok.next; }
4246       if (tok != null) jj_add_error_token(kind, i);
4247     }
4248     return (jj_scanpos.kind != kind);
4249   }
4250
4251   static final public Token getNextToken() {
4252     if (token.next != null) token = token.next;
4253     else token = token.next = token_source.getNextToken();
4254     jj_ntk = -1;
4255     jj_gen++;
4256     return token;
4257   }
4258
4259   static final public Token getToken(int index) {
4260     Token t = lookingAhead ? jj_scanpos : token;
4261     for (int i = 0; i < index; i++) {
4262       if (t.next != null) t = t.next;
4263       else t = t.next = token_source.getNextToken();
4264     }
4265     return t;
4266   }
4267
4268   static final private int jj_ntk() {
4269     if ((jj_nt=token.next) == null)
4270       return (jj_ntk = (token.next=token_source.getNextToken()).kind);
4271     else
4272       return (jj_ntk = jj_nt.kind);
4273   }
4274
4275   static private java.util.Vector jj_expentries = new java.util.Vector();
4276   static private int[] jj_expentry;
4277   static private int jj_kind = -1;
4278   static private int[] jj_lasttokens = new int[100];
4279   static private int jj_endpos;
4280
4281   static private void jj_add_error_token(int kind, int pos) {
4282     if (pos >= 100) return;
4283     if (pos == jj_endpos + 1) {
4284       jj_lasttokens[jj_endpos++] = kind;
4285     } else if (jj_endpos != 0) {
4286       jj_expentry = new int[jj_endpos];
4287       for (int i = 0; i < jj_endpos; i++) {
4288         jj_expentry[i] = jj_lasttokens[i];
4289       }
4290       boolean exists = false;
4291       for (java.util.Enumeration enum = jj_expentries.elements(); enum.hasMoreElements();) {
4292         int[] oldentry = (int[])(enum.nextElement());
4293         if (oldentry.length == jj_expentry.length) {
4294           exists = true;
4295           for (int i = 0; i < jj_expentry.length; i++) {
4296             if (oldentry[i] != jj_expentry[i]) {
4297               exists = false;
4298               break;
4299             }
4300           }
4301           if (exists) break;
4302         }
4303       }
4304       if (!exists) jj_expentries.addElement(jj_expentry);
4305       if (pos != 0) jj_lasttokens[(jj_endpos = pos) - 1] = kind;
4306     }
4307   }
4308
4309   static final public ParseException generateParseException() {
4310     jj_expentries.removeAllElements();
4311     boolean[] la1tokens = new boolean[128];
4312     for (int i = 0; i < 128; i++) {
4313       la1tokens[i] = false;
4314     }
4315     if (jj_kind >= 0) {
4316       la1tokens[jj_kind] = true;
4317       jj_kind = -1;
4318     }
4319     for (int i = 0; i < 96; i++) {
4320       if (jj_la1[i] == jj_gen) {
4321         for (int j = 0; j < 32; j++) {
4322           if ((jj_la1_0[i] & (1<<j)) != 0) {
4323             la1tokens[j] = true;
4324           }
4325           if ((jj_la1_1[i] & (1<<j)) != 0) {
4326             la1tokens[32+j] = true;
4327           }
4328           if ((jj_la1_2[i] & (1<<j)) != 0) {
4329             la1tokens[64+j] = true;
4330           }
4331           if ((jj_la1_3[i] & (1<<j)) != 0) {
4332             la1tokens[96+j] = true;
4333           }
4334         }
4335       }
4336     }
4337     for (int i = 0; i < 128; i++) {
4338       if (la1tokens[i]) {
4339         jj_expentry = new int[1];
4340         jj_expentry[0] = i;
4341         jj_expentries.addElement(jj_expentry);
4342       }
4343     }
4344     jj_endpos = 0;
4345     jj_rescan_token();
4346     jj_add_error_token(0, 0);
4347     int[][] exptokseq = new int[jj_expentries.size()][];
4348     for (int i = 0; i < jj_expentries.size(); i++) {
4349       exptokseq[i] = (int[])jj_expentries.elementAt(i);
4350     }
4351     return new ParseException(token, exptokseq, tokenImage);
4352   }
4353
4354   static final public void enable_tracing() {
4355   }
4356
4357   static final public void disable_tracing() {
4358   }
4359
4360   static final private void jj_rescan_token() {
4361     jj_rescan = true;
4362     for (int i = 0; i < 7; i++) {
4363       JJCalls p = jj_2_rtns[i];
4364       do {
4365         if (p.gen > jj_gen) {
4366           jj_la = p.arg; jj_lastpos = jj_scanpos = p.first;
4367           switch (i) {
4368             case 0: jj_3_1(); break;
4369             case 1: jj_3_2(); break;
4370             case 2: jj_3_3(); break;
4371             case 3: jj_3_4(); break;
4372             case 4: jj_3_5(); break;
4373             case 5: jj_3_6(); break;
4374             case 6: jj_3_7(); break;
4375           }
4376         }
4377         p = p.next;
4378       } while (p != null);
4379     }
4380     jj_rescan = false;
4381   }
4382
4383   static final private void jj_save(int index, int xla) {
4384     JJCalls p = jj_2_rtns[index];
4385     while (p.gen > jj_gen) {
4386       if (p.next == null) { p = p.next = new JJCalls(); break; }
4387       p = p.next;
4388     }
4389     p.gen = jj_gen + xla - jj_la; p.first = token; p.arg = xla;
4390   }
4391
4392   static final class JJCalls {
4393     int gen;
4394     Token first;
4395     int arg;
4396     JJCalls next;
4397   }
4398
4399 }