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