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