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

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