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