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

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