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