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