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.util.ArrayList;
  12 import java.io.StringReader;
  13 import java.io.*;
  14 import java.text.MessageFormat;
  15
  16 import net.sourceforge.phpeclipse.actions.PHPStartApacheAction;
  17 import net.sourceforge.phpeclipse.PHPeclipsePlugin;
  18 import net.sourceforge.phpdt.internal.compiler.ast.*;
  19 import net.sourceforge.phpdt.internal.compiler.parser.OutlineableWithChildren;
  20 import net.sourceforge.phpdt.internal.compiler.parser.Outlineable;
  21 import net.sourceforge.phpdt.internal.compiler.parser.PHPOutlineInfo;
  22 import net.sourceforge.phpdt.internal.corext.Assert;
  23
  24 /**
  25  * A new php parser.
  26  * This php parser is inspired by the Java 1.2 grammar example
  27  * given with JavaCC. You can get JavaCC at http://www.webgain.com
  28  * You can test the parser with the PHPParserTestCase2.java
  29  * @author Matthieu Casanova
  30  */
  31 public final class PHPParser extends PHPParserSuperclass implements PHPParserConstants {
  32
  33 //todo : fix the variables names bug
  34 //todo : handle tilde operator
  35
  36
  37   /** The current segment. */
  38   private static OutlineableWithChildren currentSegment;
  39
  40   private static final String PARSE_ERROR_STRING = "Parse error"; //$NON-NLS-1$
  41   private static final String PARSE_WARNING_STRING = "Warning"; //$NON-NLS-1$
  42   static PHPOutlineInfo outlineInfo;
  43
  44   /** The error level of the current ParseException. */
  45   private static int errorLevel = ERROR;
  46   /** The message of the current ParseException. If it's null it's because the parse exception wasn't handled */
  47   private static String errorMessage;
  48
  49   private static int errorStart = -1;
  50   private static int errorEnd = -1;
  51   private static PHPDocument phpDocument;
  52
  53   private static final String SYNTAX_ERROR_CHAR = "syntax error";
  54   /**
  55    * The point where html starts.
  56    * It will be used by the token manager to create HTMLCode objects
  57    */
  58   public static int htmlStart;
  59
  60   //ast stack
  61   private final static int AstStackIncrement = 100;
  62   /** The stack of node. */
  63   private static AstNode[] nodes;
  64   /** The cursor in expression stack. */
  65   private static int nodePtr;
  66
  67   public static final boolean PARSER_DEBUG = false;
  68
  69   public final void setFileToParse(final IFile fileToParse) {
  70     PHPParser.fileToParse = fileToParse;
  71   }
  72
  73   public PHPParser() {
  74   }
  75
  76   public PHPParser(final IFile fileToParse) {
  77     this(new StringReader(""));
  78     PHPParser.fileToParse = fileToParse;
  79   }
  80
  81   public static final void phpParserTester(final String strEval) throws ParseException {
  82     final StringReader stream = new StringReader(strEval);
  83     if (jj_input_stream == null) {
  84       jj_input_stream = new SimpleCharStream(stream, 1, 1);
  85     }
  86     ReInit(new StringReader(strEval));
  87     init();
  88     phpDocument = new PHPDocument(null,"_root".toCharArray());
  89     currentSegment = phpDocument;
  90     outlineInfo = new PHPOutlineInfo(null, currentSegment);
  91     PHPParserTokenManager.SwitchTo(PHPParserTokenManager.PHPPARSING);
  92     phpTest();
  93   }
  94
  95   public static final void htmlParserTester(final File fileName) throws FileNotFoundException, ParseException {
  96     final Reader stream = new FileReader(fileName);
  97     if (jj_input_stream == null) {
  98       jj_input_stream = new SimpleCharStream(stream, 1, 1);
  99     }
 100     ReInit(stream);
 101     init();
 102     phpDocument = new PHPDocument(null,"_root".toCharArray());
 103     currentSegment = phpDocument;
 104     outlineInfo = new PHPOutlineInfo(null, currentSegment);
 105     phpFile();
 106   }
 107
 108   public static final void htmlParserTester(final String strEval) throws ParseException {
 109     final StringReader stream = new StringReader(strEval);
 110     if (jj_input_stream == null) {
 111       jj_input_stream = new SimpleCharStream(stream, 1, 1);
 112     }
 113     ReInit(stream);
 114     init();
 115     phpDocument = new PHPDocument(null,"_root".toCharArray());
 116     currentSegment = phpDocument;
 117     outlineInfo = new PHPOutlineInfo(null, currentSegment);
 118     phpFile();
 119   }
 120
 121   /**
 122    * Reinitialize the parser.
 123    */
 124   private static final void init() {
 125     nodes = new AstNode[AstStackIncrement];
 126     nodePtr = -1;
 127     htmlStart = 0;
 128   }
 129
 130   /**
 131    * Add an php node on the stack.
 132    * @param node the node that will be added to the stack
 133    */
 134   private static final void pushOnAstNodes(final AstNode node) {
 135     try {
 136       nodes[++nodePtr] = node;
 137     } catch (IndexOutOfBoundsException e) {
 138       final int oldStackLength = nodes.length;
 139       final AstNode[] oldStack = nodes;
 140       nodes = new AstNode[oldStackLength + AstStackIncrement];
 141       System.arraycopy(oldStack, 0, nodes, 0, oldStackLength);
 142       nodePtr = oldStackLength;
 143       nodes[nodePtr] = node;
 144     }
 145   }
 146
 147   public final PHPOutlineInfo parseInfo(final Object parent, final String s) {
 148     phpDocument = new PHPDocument(parent,"_root".toCharArray());
 149     currentSegment = phpDocument;
 150     outlineInfo = new PHPOutlineInfo(parent, currentSegment);
 151     final StringReader stream = new StringReader(s);
 152     if (jj_input_stream == null) {
 153       jj_input_stream = new SimpleCharStream(stream, 1, 1);
 154     }
 155     ReInit(stream);
 156     init();
 157     try {
 158       parse();
 159       phpDocument.nodes = new AstNode[nodes.length];
 160       System.arraycopy(nodes,0,phpDocument.nodes,0,nodes.length);
 161       if (PHPeclipsePlugin.DEBUG) {
 162         PHPeclipsePlugin.log(1,phpDocument.toString());
 163       }
 164     } catch (ParseException e) {
 165       processParseException(e);
 166     }
 167     return outlineInfo;
 168   }
 169
 170   /**
 171    * This function will throw the exception if we are in debug mode
 172    * and process it if we are in production mode.
 173    * this should be fast since the PARSER_DEBUG is static final so the difference will be at compile time
 174    * @param e the exception
 175    * @throws ParseException the thrown exception
 176    */
 177   private static void processParseExceptionDebug(final ParseException e) throws ParseException {
 178     if (PARSER_DEBUG) {
 179       throw e;
 180     }
 181     processParseException(e);
 182   }
 183   /**
 184    * This method will process the parse exception.
 185    * If the error message is null, the parse exception wasn't catched and a trace is written in the log
 186    * @param e the ParseException
 187    */
 188   private static void processParseException(final ParseException e) {
 189     if (errorMessage == null) {
 190       PHPeclipsePlugin.log(e);
 191       errorMessage = "this exception wasn't handled by the parser please tell us how to reproduce it";
 192       errorStart = e.currentToken.sourceStart;
 193       errorEnd   = e.currentToken.sourceEnd;
 194     }
 195     setMarker(e);
 196     errorMessage = null;
 197   //  if (PHPeclipsePlugin.DEBUG) PHPeclipsePlugin.log(e);
 198   }
 199
 200   /**
 201    * Create marker for the parse error.
 202    * @param e the ParseException
 203    */
 204   private static void setMarker(final ParseException e) {
 205     try {
 206       if (errorStart == -1) {
 207         setMarker(fileToParse,
 208                   errorMessage,
 209                   e.currentToken.sourceStart,
 210                   e.currentToken.sourceEnd,
 211                   errorLevel,
 212                   "Line " + e.currentToken.beginLine+", "+e.currentToken.sourceStart+":"+e.currentToken.sourceEnd);
 213       } else {
 214         setMarker(fileToParse,
 215                   errorMessage,
 216                   errorStart,
 217                   errorEnd,
 218                   errorLevel,
 219                   "Line " + e.currentToken.beginLine+", "+errorStart+":"+errorEnd);
 220         errorStart = -1;
 221         errorEnd = -1;
 222       }
 223     } catch (CoreException e2) {
 224       PHPeclipsePlugin.log(e2);
 225     }
 226   }
 227
 228   private static void scanLine(final String output,
 229                                final IFile file,
 230                                final int indx,
 231                                final int brIndx) throws CoreException {
 232     String current;
 233     final StringBuffer lineNumberBuffer = new StringBuffer(10);
 234     char ch;
 235     current = output.substring(indx, brIndx);
 236
 237     if (current.indexOf(PARSE_WARNING_STRING) != -1 || current.indexOf(PARSE_ERROR_STRING) != -1) {
 238       final int onLine = current.indexOf("on line <b>");
 239       if (onLine != -1) {
 240         lineNumberBuffer.delete(0, lineNumberBuffer.length());
 241         for (int i = onLine; i < current.length(); i++) {
 242           ch = current.charAt(i);
 243           if ('0' <= ch && '9' >= ch) {
 244             lineNumberBuffer.append(ch);
 245           }
 246         }
 247
 248         final int lineNumber = Integer.parseInt(lineNumberBuffer.toString());
 249
 250         final Hashtable attributes = new Hashtable();
 251
 252         current = current.replaceAll("\n", "");
 253         current = current.replaceAll("<b>", "");
 254         current = current.replaceAll("</b>", "");
 255         MarkerUtilities.setMessage(attributes, current);
 256
 257         if (current.indexOf(PARSE_ERROR_STRING) != -1)
 258           attributes.put(IMarker.SEVERITY, new Integer(IMarker.SEVERITY_ERROR));
 259         else if (current.indexOf(PARSE_WARNING_STRING) != -1)
 260           attributes.put(IMarker.SEVERITY, new Integer(IMarker.SEVERITY_WARNING));
 261         else
 262           attributes.put(IMarker.SEVERITY, new Integer(IMarker.SEVERITY_INFO));
 263         MarkerUtilities.setLineNumber(attributes, lineNumber);
 264         MarkerUtilities.createMarker(file, attributes, IMarker.PROBLEM);
 265       }
 266     }
 267   }
 268
 269   public final void parse(final String s) {
 270     final StringReader stream = new StringReader(s);
 271     if (jj_input_stream == null) {
 272       jj_input_stream = new SimpleCharStream(stream, 1, 1);
 273     }
 274     ReInit(stream);
 275     init();
 276     try {
 277       parse();
 278     } catch (ParseException e) {
 279       processParseException(e);
 280     }
 281   }
 282
 283   /**
 284    * Call the php parse command ( php -l -f &lt;filename&gt; )
 285    * and create markers according to the external parser output
 286    */
 287   public static void phpExternalParse(final IFile file) {
 288     final IPreferenceStore store = PHPeclipsePlugin.getDefault().getPreferenceStore();
 289     final String filename = file.getLocation().toString();
 290
 291     final String[] arguments = { filename };
 292     final MessageFormat form = new MessageFormat(store.getString(PHPeclipsePlugin.EXTERNAL_PARSER_PREF));
 293     final String command = form.format(arguments);
 294
 295     final String parserResult = PHPStartApacheAction.getParserOutput(command, "External parser: ");
 296
 297     try {
 298       // parse the buffer to find the errors and warnings
 299       createMarkers(parserResult, file);
 300     } catch (CoreException e) {
 301       PHPeclipsePlugin.log(e);
 302     }
 303   }
 304
 305   /**
 306    * Put a new html block in the stack.
 307    */
 308   public static final void createNewHTMLCode() {
 309     final int currentPosition = token.sourceStart;
 310     if (currentPosition == htmlStart ||
 311           currentPosition < htmlStart ||
 312           currentPosition > SimpleCharStream.currentBuffer.length()) {
 313       return;
 314     }
 315     final char[] chars = SimpleCharStream.currentBuffer.substring(htmlStart,
 316                                                                   currentPosition).toCharArray();
 317     pushOnAstNodes(new HTMLCode(chars, htmlStart,currentPosition));
 318   }
 319
 320   /** Create a new task. */
 321   public static final void createNewTask(final int todoStart) {
 322     final String  todo = SimpleCharStream.currentBuffer.substring(todoStart,
 323                                                                   SimpleCharStream.currentBuffer.indexOf("\n",
 324                                                                                                          todoStart)-1);
 325     if (!PARSER_DEBUG) {
 326       try {
 327         setMarker(fileToParse,
 328                   todo,
 329                   SimpleCharStream.getBeginLine(),
 330                   TASK,
 331                   "Line "+SimpleCharStream.getBeginLine());
 332       } catch (CoreException e) {
 333         PHPeclipsePlugin.log(e);
 334       }
 335     }
 336   }
 337
 338   private static final void parse() throws ParseException {
 339           phpFile();
 340   }
 341
 342   static final public void todo() throws ParseException {
 343  Token todoToken;
 344     todoToken = jj_consume_token(23);
 345                       createNewTask(todoToken.sourceStart);
 346   }
 347
 348   static final public void phpTest() throws ParseException {
 349     Php();
 350     jj_consume_token(0);
 351   }
 352
 353   static final public void phpFile() throws ParseException {
 354     try {
 355       label_1:
 356       while (true) {
 357         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
 358         case PHPSTARTSHORT:
 359         case PHPSTARTLONG:
 360         case PHPECHOSTART:
 361         case PHPEND:
 362         case CLASS:
 363         case FUNCTION:
 364         case IF:
 365         case ARRAY:
 366         case BREAK:
 367         case LIST:
 368         case PRINT:
 369         case ECHO:
 370         case INCLUDE:
 371         case REQUIRE:
 372         case INCLUDE_ONCE:
 373         case REQUIRE_ONCE:
 374         case GLOBAL:
 375         case DEFINE:
 376         case STATIC:
 377         case CONTINUE:
 378         case DO:
 379         case FOR:
 380         case NEW:
 381         case NULL:
 382         case RETURN:
 383         case SWITCH:
 384         case TRUE:
 385         case FALSE:
 386         case WHILE:
 387         case FOREACH:
 388         case AT:
 389         case BANG:
 390         case TILDE:
 391         case PLUS_PLUS:
 392         case MINUS_MINUS:
 393         case PLUS:
 394         case MINUS:
 395         case BIT_AND:
 396         case INTEGER_LITERAL:
 397         case FLOATING_POINT_LITERAL:
 398         case STRING_LITERAL:
 399         case DOUBLEQUOTE:
 400         case DOLLAR:
 401         case IDENTIFIER:
 402         case LPAREN:
 403         case LBRACE:
 404         case SEMICOLON:
 405           ;
 406           break;
 407         default:
 408           jj_la1[0] = jj_gen;
 409           break label_1;
 410         }
 411         PhpBlock();
 412       }
 413      PHPParser.createNewHTMLCode();
 414     } catch (TokenMgrError e) {
 415     PHPeclipsePlugin.log(e);
 416     errorStart   = SimpleCharStream.beginOffset;
 417     errorEnd     = SimpleCharStream.endOffset;
 418     errorMessage = e.getMessage();
 419     errorLevel   = ERROR;
 420     {if (true) throw generateParseException();}
 421     }
 422   }
 423
 424 /**
 425  * A php block is a <?= expression [;]?>
 426  * or <?php somephpcode ?>
 427  * or <? somephpcode ?>
 428  */
 429   static final public void PhpBlock() throws ParseException {
 430   final PHPEchoBlock phpEchoBlock;
 431   final Token token,phpEnd;
 432     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
 433     case PHPECHOSTART:
 434       phpEchoBlock = phpEchoBlock();
 435    pushOnAstNodes(phpEchoBlock);
 436       break;
 437     case PHPSTARTSHORT:
 438     case PHPSTARTLONG:
 439     case PHPEND:
 440     case CLASS:
 441     case FUNCTION:
 442     case IF:
 443     case ARRAY:
 444     case BREAK:
 445     case LIST:
 446     case PRINT:
 447     case ECHO:
 448     case INCLUDE:
 449     case REQUIRE:
 450     case INCLUDE_ONCE:
 451     case REQUIRE_ONCE:
 452     case GLOBAL:
 453     case DEFINE:
 454     case STATIC:
 455     case CONTINUE:
 456     case DO:
 457     case FOR:
 458     case NEW:
 459     case NULL:
 460     case RETURN:
 461     case SWITCH:
 462     case TRUE:
 463     case FALSE:
 464     case WHILE:
 465     case FOREACH:
 466     case AT:
 467     case BANG:
 468     case TILDE:
 469     case PLUS_PLUS:
 470     case MINUS_MINUS:
 471     case PLUS:
 472     case MINUS:
 473     case BIT_AND:
 474     case INTEGER_LITERAL:
 475     case FLOATING_POINT_LITERAL:
 476     case STRING_LITERAL:
 477     case DOUBLEQUOTE:
 478     case DOLLAR:
 479     case IDENTIFIER:
 480     case LPAREN:
 481     case LBRACE:
 482     case SEMICOLON:
 483       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
 484       case PHPSTARTSHORT:
 485       case PHPSTARTLONG:
 486         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
 487         case PHPSTARTLONG:
 488           jj_consume_token(PHPSTARTLONG);
 489           break;
 490         case PHPSTARTSHORT:
 491           token = jj_consume_token(PHPSTARTSHORT);
 492      try {
 493       setMarker(fileToParse,
 494                 "You should use '<?php' instead of '<?' it will avoid some problems with XML",
 495                 token.sourceStart,
 496                 token.sourceEnd,
 497                 INFO,
 498                 "Line " + token.beginLine);
 499     } catch (CoreException e) {
 500       PHPeclipsePlugin.log(e);
 501     }
 502           break;
 503         default:
 504           jj_la1[1] = jj_gen;
 505           jj_consume_token(-1);
 506           throw new ParseException();
 507         }
 508         break;
 509       default:
 510         jj_la1[2] = jj_gen;
 511         ;
 512       }
 513    PHPParser.createNewHTMLCode();
 514       Php();
 515       try {
 516         phpEnd = jj_consume_token(PHPEND);
 517     htmlStart = phpEnd.sourceEnd;
 518       } catch (ParseException e) {
 519     errorMessage = "'?>' expected";
 520     errorLevel   = ERROR;
 521     errorStart = SimpleCharStream.getPosition() - e.currentToken.next.image.length() + 1;
 522     errorEnd   = SimpleCharStream.getPosition() + 1;
 523     processParseExceptionDebug(e);
 524       }
 525       break;
 526     default:
 527       jj_la1[3] = jj_gen;
 528       jj_consume_token(-1);
 529       throw new ParseException();
 530     }
 531   }
 532
 533   static final public PHPEchoBlock phpEchoBlock() throws ParseException {
 534   final Expression expr;
 535   final PHPEchoBlock echoBlock;
 536   final Token token, token2;
 537     token = jj_consume_token(PHPECHOSTART);
 538                           PHPParser.createNewHTMLCode();
 539     expr = Expression();
 540     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
 541     case SEMICOLON:
 542       jj_consume_token(SEMICOLON);
 543       break;
 544     default:
 545       jj_la1[4] = jj_gen;
 546       ;
 547     }
 548     token2 = jj_consume_token(PHPEND);
 549   htmlStart = token2.sourceEnd;
 550
 551   echoBlock = new PHPEchoBlock(expr,token.sourceStart,token2.sourceEnd);
 552   pushOnAstNodes(echoBlock);
 553   {if (true) return echoBlock;}
 554     throw new Error("Missing return statement in function");
 555   }
 556
 557   static final public void Php() throws ParseException {
 558     label_2:
 559     while (true) {
 560       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
 561       case CLASS:
 562       case FUNCTION:
 563       case IF:
 564       case ARRAY:
 565       case BREAK:
 566       case LIST:
 567       case PRINT:
 568       case ECHO:
 569       case INCLUDE:
 570       case REQUIRE:
 571       case INCLUDE_ONCE:
 572       case REQUIRE_ONCE:
 573       case GLOBAL:
 574       case DEFINE:
 575       case STATIC:
 576       case CONTINUE:
 577       case DO:
 578       case FOR:
 579       case NEW:
 580       case NULL:
 581       case RETURN:
 582       case SWITCH:
 583       case TRUE:
 584       case FALSE:
 585       case WHILE:
 586       case FOREACH:
 587       case AT:
 588       case BANG:
 589       case TILDE:
 590       case PLUS_PLUS:
 591       case MINUS_MINUS:
 592       case PLUS:
 593       case MINUS:
 594       case BIT_AND:
 595       case INTEGER_LITERAL:
 596       case FLOATING_POINT_LITERAL:
 597       case STRING_LITERAL:
 598       case DOUBLEQUOTE:
 599       case DOLLAR:
 600       case IDENTIFIER:
 601       case LPAREN:
 602       case LBRACE:
 603       case SEMICOLON:
 604         ;
 605         break;
 606       default:
 607         jj_la1[5] = jj_gen;
 608         break label_2;
 609       }
 610       BlockStatement();
 611     }
 612   }
 613
 614   static final public ClassDeclaration ClassDeclaration() throws ParseException {
 615   final ClassDeclaration classDeclaration;
 616   Token className = null;
 617   final Token superclassName, token, extendsToken;
 618   String classNameImage = SYNTAX_ERROR_CHAR;
 619   String superclassNameImage = null;
 620   final int classEnd;
 621     token = jj_consume_token(CLASS);
 622     try {
 623       className = jj_consume_token(IDENTIFIER);
 624      classNameImage = className.image;
 625     } catch (ParseException e) {
 626     errorMessage = "unexpected token : '"+ e.currentToken.next.image +"', identifier expected";
 627     errorLevel   = ERROR;
 628     errorStart   = token.sourceEnd+1;
 629     errorEnd     = token.sourceEnd+1;
 630     processParseExceptionDebug(e);
 631     }
 632     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
 633     case EXTENDS:
 634       extendsToken = jj_consume_token(EXTENDS);
 635       try {
 636         superclassName = jj_consume_token(IDENTIFIER);
 637        superclassNameImage = superclassName.image;
 638       } catch (ParseException e) {
 639       errorMessage = "unexpected token : '"+ e.currentToken.next.image +"', identifier expected";
 640       errorLevel   = ERROR;
 641       errorStart = extendsToken.sourceEnd+1;
 642       errorEnd   = extendsToken.sourceEnd+1;
 643       processParseExceptionDebug(e);
 644       superclassNameImage = SYNTAX_ERROR_CHAR;
 645       }
 646       break;
 647     default:
 648       jj_la1[6] = jj_gen;
 649       ;
 650     }
 651     int start, end;
 652     if (className == null) {
 653       start = token.sourceStart;
 654       end = token.sourceEnd;
 655     } else {
 656       start = className.sourceStart;
 657       end = className.sourceEnd;
 658     }
 659     if (superclassNameImage == null) {
 660
 661       classDeclaration = new ClassDeclaration(currentSegment,
 662                                               classNameImage,
 663                                               start,
 664                                               end);
 665     } else {
 666       classDeclaration = new ClassDeclaration(currentSegment,
 667                                               classNameImage,
 668                                               superclassNameImage,
 669                                               start,
 670                                               end);
 671     }
 672       currentSegment.add(classDeclaration);
 673       currentSegment = classDeclaration;
 674     classEnd = ClassBody(classDeclaration);
 675    currentSegment = (OutlineableWithChildren) currentSegment.getParent();
 676    classDeclaration.sourceEnd = classEnd;
 677    pushOnAstNodes(classDeclaration);
 678    {if (true) return classDeclaration;}
 679     throw new Error("Missing return statement in function");
 680   }
 681
 682   static final public int ClassBody(final ClassDeclaration classDeclaration) throws ParseException {
 683 Token token;
 684     try {
 685       jj_consume_token(LBRACE);
 686     } catch (ParseException e) {
 687     errorMessage = "unexpected token : '"+ e.currentToken.next.image + "'. '{' expected";
 688     errorLevel   = ERROR;
 689     errorStart = SimpleCharStream.getPosition() - e.currentToken.next.image.length() + 1;
 690     errorEnd   = SimpleCharStream.getPosition() + 1;
 691     processParseExceptionDebug(e);
 692     }
 693     label_3:
 694     while (true) {
 695       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
 696       case FUNCTION:
 697       case VAR:
 698         ;
 699         break;
 700       default:
 701         jj_la1[7] = jj_gen;
 702         break label_3;
 703       }
 704       ClassBodyDeclaration(classDeclaration);
 705     }
 706     try {
 707       token = jj_consume_token(RBRACE);
 708      {if (true) return token.sourceEnd;}
 709     } catch (ParseException e) {
 710     errorMessage = "unexpected token : '"+ e.currentToken.next.image +"'. 'var', 'function' or '}' expected";
 711     errorLevel   = ERROR;
 712     errorStart = SimpleCharStream.getPosition() - e.currentToken.next.image.length() + 1;
 713     errorEnd   = SimpleCharStream.getPosition() + 1;
 714     processParseExceptionDebug(e);
 715     {if (true) return PHPParser.token.sourceEnd;}
 716     }
 717     throw new Error("Missing return statement in function");
 718   }
 719
 720 /**
 721  * A class can contain only methods and fields.
 722  */
 723   static final public void ClassBodyDeclaration(final ClassDeclaration classDeclaration) throws ParseException {
 724   final MethodDeclaration method;
 725   final FieldDeclaration field;
 726     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
 727     case FUNCTION:
 728       method = MethodDeclaration();
 729                                 method.analyzeCode();
 730                                 classDeclaration.addMethod(method);
 731       break;
 732     case VAR:
 733       field = FieldDeclaration();
 734                                 classDeclaration.addField(field);
 735       break;
 736     default:
 737       jj_la1[8] = jj_gen;
 738       jj_consume_token(-1);
 739       throw new ParseException();
 740     }
 741   }
 742
 743 /**
 744  * A class field declaration : it's var VariableDeclarator() (, VariableDeclarator())*;.
 745  * it is only used by ClassBodyDeclaration()
 746  */
 747   static final public FieldDeclaration FieldDeclaration() throws ParseException {
 748   VariableDeclaration variableDeclaration;
 749   final VariableDeclaration[] list;
 750   final ArrayList arrayList = new ArrayList();
 751   final Token token;
 752   Token token2 = null;
 753   int pos;
 754     token = jj_consume_token(VAR);
 755     variableDeclaration = VariableDeclaratorNoSuffix();
 756     arrayList.add(variableDeclaration);
 757     outlineInfo.addVariable(variableDeclaration.name());
 758     pos = variableDeclaration.sourceEnd;
 759     label_4:
 760     while (true) {
 761       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
 762       case COMMA:
 763         ;
 764         break;
 765       default:
 766         jj_la1[9] = jj_gen;
 767         break label_4;
 768       }
 769       jj_consume_token(COMMA);
 770       variableDeclaration = VariableDeclaratorNoSuffix();
 771         arrayList.add(variableDeclaration);
 772         outlineInfo.addVariable(variableDeclaration.name());
 773         pos = variableDeclaration.sourceEnd;
 774     }
 775     try {
 776       token2 = jj_consume_token(SEMICOLON);
 777     } catch (ParseException e) {
 778     errorMessage = "unexpected token : '"+ e.currentToken.next.image +"'. A ';' was expected after variable declaration";
 779     errorLevel   = ERROR;
 780     errorStart   = pos+1;
 781     errorEnd     = pos+1;
 782     processParseExceptionDebug(e);
 783     }
 784    list = new VariableDeclaration[arrayList.size()];
 785    arrayList.toArray(list);
 786    int end;
 787    if (token2 == null) {
 788      end = list[list.length-1].sourceEnd;
 789    } else {
 790      end = token2.sourceEnd;
 791    }
 792    {if (true) return new FieldDeclaration(list,
 793                                token.sourceStart,
 794                                end,
 795                                currentSegment);}
 796     throw new Error("Missing return statement in function");
 797   }
 798
 799 /**
 800  * a strict variable declarator : there cannot be a suffix here.
 801  * It will be used by fields and formal parameters
 802  */
 803   static final public VariableDeclaration VariableDeclaratorNoSuffix() throws ParseException {
 804   final Token token, lbrace,rbrace;
 805   Expression expr, initializer = null;
 806   Token assignToken;
 807   Variable variable;
 808     jj_consume_token(DOLLAR);
 809     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
 810     case IDENTIFIER:
 811       token = jj_consume_token(IDENTIFIER);
 812       variable = new Variable(token.image,token.sourceStart,token.sourceEnd);
 813       break;
 814     case LBRACE:
 815       lbrace = jj_consume_token(LBRACE);
 816       expr = Expression();
 817       rbrace = jj_consume_token(RBRACE);
 818       variable = new Variable(expr,lbrace.sourceStart,rbrace.sourceEnd);
 819       break;
 820     default:
 821       jj_la1[10] = jj_gen;
 822       jj_consume_token(-1);
 823       throw new ParseException();
 824     }
 825     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
 826     case ASSIGN:
 827       assignToken = jj_consume_token(ASSIGN);
 828       try {
 829         initializer = VariableInitializer();
 830       } catch (ParseException e) {
 831       errorMessage = "Literal expression expected in variable initializer";
 832       errorLevel   = ERROR;
 833       errorStart = assignToken.sourceEnd +1;
 834       errorEnd   = assignToken.sourceEnd +1;
 835       processParseExceptionDebug(e);
 836       }
 837       break;
 838     default:
 839       jj_la1[11] = jj_gen;
 840       ;
 841     }
 842   if (initializer == null) {
 843     {if (true) return new VariableDeclaration(currentSegment,
 844                                    variable,
 845                                    variable.sourceStart,
 846                                    variable.sourceEnd);}
 847   }
 848   {if (true) return new VariableDeclaration(currentSegment,
 849                                  variable,
 850                                  initializer,
 851                                  VariableDeclaration.EQUAL,
 852                                  variable.sourceStart);}
 853     throw new Error("Missing return statement in function");
 854   }
 855
 856 /**
 857  * this will be used by static statement
 858  */
 859   static final public VariableDeclaration VariableDeclarator() throws ParseException {
 860   final AbstractVariable variable;
 861   Expression initializer = null;
 862   final Token token;
 863     variable = VariableDeclaratorId();
 864     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
 865     case ASSIGN:
 866       token = jj_consume_token(ASSIGN);
 867       try {
 868         initializer = VariableInitializer();
 869       } catch (ParseException e) {
 870       errorMessage = "Literal expression expected in variable initializer";
 871       errorLevel   = ERROR;
 872       errorStart = token.sourceEnd+1;
 873       errorEnd   = token.sourceEnd+1;
 874       processParseExceptionDebug(e);
 875       }
 876       break;
 877     default:
 878       jj_la1[12] = jj_gen;
 879       ;
 880     }
 881   if (initializer == null) {
 882     {if (true) return new VariableDeclaration(currentSegment,
 883                                    variable,
 884                                    variable.sourceStart,
 885                                    variable.sourceEnd);}
 886   }
 887     {if (true) return new VariableDeclaration(currentSegment,
 888                                    variable,
 889                                    initializer,
 890                                    VariableDeclaration.EQUAL,
 891                                    variable.sourceStart);}
 892     throw new Error("Missing return statement in function");
 893   }
 894
 895 /**
 896  * A Variable name.
 897  * @return the variable name (with suffix)
 898  */
 899   static final public AbstractVariable VariableDeclaratorId() throws ParseException {
 900   final Variable var;
 901   AbstractVariable expression = null;
 902     try {
 903       var = Variable();
 904       label_5:
 905       while (true) {
 906         if (jj_2_1(2)) {
 907           ;
 908         } else {
 909           break label_5;
 910         }
 911         expression = VariableSuffix(var);
 912       }
 913      if (expression == null) {
 914        {if (true) return var;}
 915      }
 916      {if (true) return expression;}
 917     } catch (ParseException e) {
 918     errorMessage = "'$' expected for variable identifier";
 919     errorLevel   = ERROR;
 920     errorStart = SimpleCharStream.getPosition() - e.currentToken.next.image.length() + 1;
 921     errorEnd   = SimpleCharStream.getPosition() + 1;
 922     {if (true) throw e;}
 923     }
 924     throw new Error("Missing return statement in function");
 925   }
 926
 927   static final public Variable Variable() throws ParseException {
 928   Variable variable = null;
 929   final Token token;
 930     token = jj_consume_token(DOLLAR);
 931     variable = Var();
 932     {if (true) return variable;}
 933     throw new Error("Missing return statement in function");
 934   }
 935
 936   static final public Variable Var() throws ParseException {
 937   Variable variable = null;
 938   final Token token,token2;
 939   ConstantIdentifier constant;
 940   Expression expression;
 941     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
 942     case DOLLAR:
 943       token = jj_consume_token(DOLLAR);
 944       variable = Var();
 945    {if (true) return new Variable(variable,variable.sourceStart,variable.sourceEnd);}
 946       break;
 947     case LBRACE:
 948       token = jj_consume_token(LBRACE);
 949       expression = Expression();
 950       token2 = jj_consume_token(RBRACE);
 951    {if (true) return new Variable(expression,
 952                        token.sourceStart,
 953                        token2.sourceEnd);}
 954       break;
 955     case IDENTIFIER:
 956       token = jj_consume_token(IDENTIFIER);
 957    {if (true) return new Variable(token.image,token.sourceStart,token.sourceEnd);}
 958       break;
 959     default:
 960       jj_la1[13] = jj_gen;
 961       jj_consume_token(-1);
 962       throw new ParseException();
 963     }
 964     throw new Error("Missing return statement in function");
 965   }
 966
 967   static final public Expression VariableInitializer() throws ParseException {
 968   final Expression expr;
 969   final Token token, token2;
 970     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
 971     case NULL:
 972     case TRUE:
 973     case FALSE:
 974     case INTEGER_LITERAL:
 975     case FLOATING_POINT_LITERAL:
 976     case STRING_LITERAL:
 977     case DOUBLEQUOTE:
 978       expr = Literal();
 979    {if (true) return expr;}
 980       break;
 981     case MINUS:
 982       token2 = jj_consume_token(MINUS);
 983       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
 984       case INTEGER_LITERAL:
 985         token = jj_consume_token(INTEGER_LITERAL);
 986         break;
 987       case FLOATING_POINT_LITERAL:
 988         token = jj_consume_token(FLOATING_POINT_LITERAL);
 989         break;
 990       default:
 991         jj_la1[14] = jj_gen;
 992         jj_consume_token(-1);
 993         throw new ParseException();
 994       }
 995    {if (true) return new PrefixedUnaryExpression(new NumberLiteral(token),
 996                                       OperatorIds.MINUS,
 997                                       token2.sourceStart);}
 998       break;
 999     case PLUS:
1000       token2 = jj_consume_token(PLUS);
1001       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1002       case INTEGER_LITERAL:
1003         token = jj_consume_token(INTEGER_LITERAL);
1004         break;
1005       case FLOATING_POINT_LITERAL:
1006         token = jj_consume_token(FLOATING_POINT_LITERAL);
1007         break;
1008       default:
1009         jj_la1[15] = jj_gen;
1010         jj_consume_token(-1);
1011         throw new ParseException();
1012       }
1013    {if (true) return new PrefixedUnaryExpression(new NumberLiteral(token),
1014                                       OperatorIds.PLUS,
1015                                       token2.sourceStart);}
1016       break;
1017     case ARRAY:
1018       expr = ArrayDeclarator();
1019    {if (true) return expr;}
1020       break;
1021     case IDENTIFIER:
1022       token = jj_consume_token(IDENTIFIER);
1023    {if (true) return new ConstantIdentifier(token);}
1024       break;
1025     default:
1026       jj_la1[16] = jj_gen;
1027       jj_consume_token(-1);
1028       throw new ParseException();
1029     }
1030     throw new Error("Missing return statement in function");
1031   }
1032
1033   static final public ArrayVariableDeclaration ArrayVariable() throws ParseException {
1034 final Expression expr,expr2;
1035     expr = Expression();
1036     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1037     case ARRAYASSIGN:
1038       jj_consume_token(ARRAYASSIGN);
1039       expr2 = Expression();
1040      {if (true) return new ArrayVariableDeclaration(expr,expr2);}
1041       break;
1042     default:
1043       jj_la1[17] = jj_gen;
1044       ;
1045     }
1046    {if (true) return new ArrayVariableDeclaration(expr,SimpleCharStream.getPosition());}
1047     throw new Error("Missing return statement in function");
1048   }
1049
1050   static final public ArrayVariableDeclaration[] ArrayInitializer() throws ParseException {
1051   ArrayVariableDeclaration expr;
1052   final ArrayList list = new ArrayList();
1053     jj_consume_token(LPAREN);
1054     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1055     case ARRAY:
1056     case LIST:
1057     case PRINT:
1058     case NEW:
1059     case NULL:
1060     case TRUE:
1061     case FALSE:
1062     case AT:
1063     case BANG:
1064     case TILDE:
1065     case PLUS_PLUS:
1066     case MINUS_MINUS:
1067     case PLUS:
1068     case MINUS:
1069     case BIT_AND:
1070     case INTEGER_LITERAL:
1071     case FLOATING_POINT_LITERAL:
1072     case STRING_LITERAL:
1073     case DOUBLEQUOTE:
1074     case DOLLAR:
1075     case IDENTIFIER:
1076     case LPAREN:
1077       expr = ArrayVariable();
1078        list.add(expr);
1079       label_6:
1080       while (true) {
1081         if (jj_2_2(2)) {
1082           ;
1083         } else {
1084           break label_6;
1085         }
1086         jj_consume_token(COMMA);
1087         expr = ArrayVariable();
1088        list.add(expr);
1089       }
1090       break;
1091     default:
1092       jj_la1[18] = jj_gen;
1093       ;
1094     }
1095     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1096     case COMMA:
1097       jj_consume_token(COMMA);
1098                list.add(null);
1099       break;
1100     default:
1101       jj_la1[19] = jj_gen;
1102       ;
1103     }
1104     jj_consume_token(RPAREN);
1105   final ArrayVariableDeclaration[] vars = new ArrayVariableDeclaration[list.size()];
1106   list.toArray(vars);
1107   {if (true) return vars;}
1108     throw new Error("Missing return statement in function");
1109   }
1110
1111 /**
1112  * A Method Declaration.
1113  * <b>function</b> MetodDeclarator() Block()
1114  */
1115   static final public MethodDeclaration MethodDeclaration() throws ParseException {
1116   final MethodDeclaration functionDeclaration;
1117   final Block block;
1118   final OutlineableWithChildren seg = currentSegment;
1119   final Token token;
1120     token = jj_consume_token(FUNCTION);
1121     try {
1122       functionDeclaration = MethodDeclarator(token.sourceStart);
1123      outlineInfo.addVariable(functionDeclaration.name);
1124     } catch (ParseException e) {
1125     if (errorMessage != null)  {if (true) throw e;}
1126     errorMessage = "unexpected token : '"+ e.currentToken.next.image +"', function identifier expected";
1127     errorLevel   = ERROR;
1128     errorStart = SimpleCharStream.getPosition() - e.currentToken.next.image.length() + 1;
1129     errorEnd   = SimpleCharStream.getPosition() + 1;
1130     {if (true) throw e;}
1131     }
1132    currentSegment = functionDeclaration;
1133     block = Block();
1134    functionDeclaration.statements = block.statements;
1135    currentSegment = seg;
1136    {if (true) return functionDeclaration;}
1137     throw new Error("Missing return statement in function");
1138   }
1139
1140 /**
1141  * A MethodDeclarator.
1142  * [&] IDENTIFIER(parameters ...).
1143  * @return a function description for the outline
1144  */
1145   static final public MethodDeclaration MethodDeclarator(final int start) throws ParseException {
1146   Token identifier = null;
1147   Token reference = null;
1148   final Hashtable formalParameters = new Hashtable();
1149   String identifierChar = SYNTAX_ERROR_CHAR;
1150   int end = start;
1151     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1152     case BIT_AND:
1153       reference = jj_consume_token(BIT_AND);
1154                           end = reference.sourceEnd;
1155       break;
1156     default:
1157       jj_la1[20] = jj_gen;
1158       ;
1159     }
1160     try {
1161       identifier = jj_consume_token(IDENTIFIER);
1162       identifierChar = identifier.image;
1163       end = identifier.sourceEnd;
1164     } catch (ParseException e) {
1165     errorMessage = "unexpected token : '"+ e.currentToken.next.image +"', function identifier expected";
1166     errorLevel   = ERROR;
1167     errorStart = e.currentToken.sourceEnd;
1168     errorEnd   = e.currentToken.next.sourceStart;
1169     processParseExceptionDebug(e);
1170     }
1171     end = FormalParameters(formalParameters);
1172   int nameStart, nameEnd;
1173   if (identifier == null) {
1174     if (reference == null) {
1175       nameStart = start + 9;
1176       nameEnd = start + 10;
1177     } else {
1178       nameStart = reference.sourceEnd + 1;
1179       nameEnd = reference.sourceEnd + 2;
1180     }
1181   } else {
1182       nameStart = identifier.sourceStart;
1183       nameEnd = identifier.sourceEnd;
1184   }
1185   {if (true) return new MethodDeclaration(currentSegment,
1186                                identifierChar,
1187                                formalParameters,
1188                                reference != null,
1189                                nameStart,
1190                                nameEnd,
1191                                start,
1192                                end);}
1193     throw new Error("Missing return statement in function");
1194   }
1195
1196 /**
1197  * FormalParameters follows method identifier.
1198  * (FormalParameter())
1199  */
1200   static final public int FormalParameters(final Hashtable parameters) throws ParseException {
1201   VariableDeclaration var;
1202   final Token token;
1203   Token tok = PHPParser.token;
1204   int end = tok.sourceEnd;
1205     try {
1206       tok = jj_consume_token(LPAREN);
1207    end = tok.sourceEnd;
1208     } catch (ParseException e) {
1209     errorMessage = "unexpected token : '"+ e.currentToken.next.image +"', '(' expected after function identifier";
1210     errorLevel   = ERROR;
1211     errorStart = e.currentToken.next.sourceStart;
1212     errorEnd   = e.currentToken.next.sourceEnd;
1213     processParseExceptionDebug(e);
1214     }
1215     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1216     case BIT_AND:
1217     case DOLLAR:
1218       var = FormalParameter();
1219      parameters.put(var.name(),var);end = var.sourceEnd;
1220       label_7:
1221       while (true) {
1222         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1223         case COMMA:
1224           ;
1225           break;
1226         default:
1227           jj_la1[21] = jj_gen;
1228           break label_7;
1229         }
1230         jj_consume_token(COMMA);
1231         var = FormalParameter();
1232        parameters.put(var.name(),var);end = var.sourceEnd;
1233       }
1234       break;
1235     default:
1236       jj_la1[22] = jj_gen;
1237       ;
1238     }
1239     try {
1240       token = jj_consume_token(RPAREN);
1241      end = token.sourceEnd;
1242     } catch (ParseException e) {
1243     errorMessage = "')' expected";
1244     errorLevel   = ERROR;
1245     errorStart = e.currentToken.next.sourceStart;
1246     errorEnd   = e.currentToken.next.sourceEnd;
1247     processParseExceptionDebug(e);
1248     }
1249   {if (true) return end;}
1250     throw new Error("Missing return statement in function");
1251   }
1252
1253 /**
1254  * A formal parameter.
1255  * $varname[=value] (,$varname[=value])
1256  */
1257   static final public VariableDeclaration FormalParameter() throws ParseException {
1258   final VariableDeclaration variableDeclaration;
1259   Token token = null;
1260     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1261     case BIT_AND:
1262       token = jj_consume_token(BIT_AND);
1263       break;
1264     default:
1265       jj_la1[23] = jj_gen;
1266       ;
1267     }
1268     variableDeclaration = VariableDeclaratorNoSuffix();
1269     if (token != null) {
1270       variableDeclaration.setReference(true);
1271     }
1272     {if (true) return variableDeclaration;}
1273     throw new Error("Missing return statement in function");
1274   }
1275
1276   static final public ConstantIdentifier Type() throws ParseException {
1277  final Token token;
1278     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1279     case STRING:
1280       token = jj_consume_token(STRING);
1281                        {if (true) return new ConstantIdentifier(token);}
1282       break;
1283     case BOOL:
1284       token = jj_consume_token(BOOL);
1285                        {if (true) return new ConstantIdentifier(token);}
1286       break;
1287     case BOOLEAN:
1288       token = jj_consume_token(BOOLEAN);
1289                        {if (true) return new ConstantIdentifier(token);}
1290       break;
1291     case REAL:
1292       token = jj_consume_token(REAL);
1293                        {if (true) return new ConstantIdentifier(token);}
1294       break;
1295     case DOUBLE:
1296       token = jj_consume_token(DOUBLE);
1297                        {if (true) return new ConstantIdentifier(token);}
1298       break;
1299     case FLOAT:
1300       token = jj_consume_token(FLOAT);
1301                        {if (true) return new ConstantIdentifier(token);}
1302       break;
1303     case INT:
1304       token = jj_consume_token(INT);
1305                        {if (true) return new ConstantIdentifier(token);}
1306       break;
1307     case INTEGER:
1308       token = jj_consume_token(INTEGER);
1309                        {if (true) return new ConstantIdentifier(token);}
1310       break;
1311     case OBJECT:
1312       token = jj_consume_token(OBJECT);
1313                        {if (true) return new ConstantIdentifier(token);}
1314       break;
1315     default:
1316       jj_la1[24] = jj_gen;
1317       jj_consume_token(-1);
1318       throw new ParseException();
1319     }
1320     throw new Error("Missing return statement in function");
1321   }
1322
1323   static final public Expression Expression() throws ParseException {
1324   final Expression expr;
1325   Expression initializer = null;
1326   int assignOperator = -1;
1327     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1328     case ARRAY:
1329     case NEW:
1330     case NULL:
1331     case TRUE:
1332     case FALSE:
1333     case AT:
1334     case BANG:
1335     case TILDE:
1336     case PLUS_PLUS:
1337     case MINUS_MINUS:
1338     case PLUS:
1339     case MINUS:
1340     case BIT_AND:
1341     case INTEGER_LITERAL:
1342     case FLOATING_POINT_LITERAL:
1343     case STRING_LITERAL:
1344     case DOUBLEQUOTE:
1345     case DOLLAR:
1346     case IDENTIFIER:
1347     case LPAREN:
1348       expr = ConditionalExpression();
1349       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1350       case ASSIGN:
1351       case PLUSASSIGN:
1352       case MINUSASSIGN:
1353       case STARASSIGN:
1354       case SLASHASSIGN:
1355       case ANDASSIGN:
1356       case ORASSIGN:
1357       case XORASSIGN:
1358       case DOTASSIGN:
1359       case REMASSIGN:
1360       case TILDEEQUAL:
1361       case LSHIFTASSIGN:
1362       case RSIGNEDSHIFTASSIGN:
1363         assignOperator = AssignmentOperator();
1364         try {
1365           initializer = Expression();
1366         } catch (ParseException e) {
1367       if (errorMessage != null) {
1368         {if (true) throw e;}
1369       }
1370       errorMessage = "unexpected token : '"+ e.currentToken.next.image +"', expression expected";
1371       errorLevel   = ERROR;
1372       errorEnd   = SimpleCharStream.getPosition();
1373       {if (true) throw e;}
1374         }
1375         break;
1376       default:
1377         jj_la1[25] = jj_gen;
1378         ;
1379       }
1380     if (assignOperator != -1) {// todo : change this, very very bad :(
1381         if (expr instanceof AbstractVariable) {
1382           {if (true) return new VariableDeclaration(currentSegment,
1383                                          (AbstractVariable) expr,
1384                                          initializer,
1385                                          expr.sourceStart,
1386                                          initializer.sourceEnd);}
1387         }
1388         String varName = expr.toStringExpression().substring(1);
1389         {if (true) return new VariableDeclaration(currentSegment,
1390                                        new Variable(varName,
1391                                                     expr.sourceStart,
1392                                                     expr.sourceEnd),
1393                                        expr.sourceStart,
1394                                        initializer.sourceEnd);}
1395     }
1396     {if (true) return expr;}
1397       break;
1398     case LIST:
1399     case PRINT:
1400       expr = ExpressionWBang();
1401                                   {if (true) return expr;}
1402       break;
1403     default:
1404       jj_la1[26] = jj_gen;
1405       jj_consume_token(-1);
1406       throw new ParseException();
1407     }
1408     throw new Error("Missing return statement in function");
1409   }
1410
1411   static final public Expression ExpressionWBang() throws ParseException {
1412   final Expression expr;
1413   final Token token;
1414     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1415     case BANG:
1416       token = jj_consume_token(BANG);
1417       expr = ExpressionWBang();
1418    {if (true) return new PrefixedUnaryExpression(expr,OperatorIds.NOT,token.sourceStart);}
1419       break;
1420     case LIST:
1421     case PRINT:
1422       expr = ExpressionNoBang();
1423                              {if (true) return expr;}
1424       break;
1425     default:
1426       jj_la1[27] = jj_gen;
1427       jj_consume_token(-1);
1428       throw new ParseException();
1429     }
1430     throw new Error("Missing return statement in function");
1431   }
1432
1433   static final public Expression ExpressionNoBang() throws ParseException {
1434   Expression expr;
1435     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1436     case LIST:
1437       expr = ListExpression();
1438                               {if (true) return expr;}
1439       break;
1440     case PRINT:
1441       expr = PrintExpression();
1442                               {if (true) return expr;}
1443       break;
1444     default:
1445       jj_la1[28] = jj_gen;
1446       jj_consume_token(-1);
1447       throw new ParseException();
1448     }
1449     throw new Error("Missing return statement in function");
1450   }
1451
1452 /**
1453  * Any assignement operator.
1454  * @return the assignement operator id
1455  */
1456   static final public int AssignmentOperator() throws ParseException {
1457     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1458     case ASSIGN:
1459       jj_consume_token(ASSIGN);
1460                         {if (true) return VariableDeclaration.EQUAL;}
1461       break;
1462     case STARASSIGN:
1463       jj_consume_token(STARASSIGN);
1464                         {if (true) return VariableDeclaration.STAR_EQUAL;}
1465       break;
1466     case SLASHASSIGN:
1467       jj_consume_token(SLASHASSIGN);
1468                         {if (true) return VariableDeclaration.SLASH_EQUAL;}
1469       break;
1470     case REMASSIGN:
1471       jj_consume_token(REMASSIGN);
1472                         {if (true) return VariableDeclaration.REM_EQUAL;}
1473       break;
1474     case PLUSASSIGN:
1475       jj_consume_token(PLUSASSIGN);
1476                         {if (true) return VariableDeclaration.PLUS_EQUAL;}
1477       break;
1478     case MINUSASSIGN:
1479       jj_consume_token(MINUSASSIGN);
1480                         {if (true) return VariableDeclaration.MINUS_EQUAL;}
1481       break;
1482     case LSHIFTASSIGN:
1483       jj_consume_token(LSHIFTASSIGN);
1484                         {if (true) return VariableDeclaration.LSHIFT_EQUAL;}
1485       break;
1486     case RSIGNEDSHIFTASSIGN:
1487       jj_consume_token(RSIGNEDSHIFTASSIGN);
1488                         {if (true) return VariableDeclaration.RSIGNEDSHIFT_EQUAL;}
1489       break;
1490     case ANDASSIGN:
1491       jj_consume_token(ANDASSIGN);
1492                         {if (true) return VariableDeclaration.AND_EQUAL;}
1493       break;
1494     case XORASSIGN:
1495       jj_consume_token(XORASSIGN);
1496                         {if (true) return VariableDeclaration.XOR_EQUAL;}
1497       break;
1498     case ORASSIGN:
1499       jj_consume_token(ORASSIGN);
1500                         {if (true) return VariableDeclaration.OR_EQUAL;}
1501       break;
1502     case DOTASSIGN:
1503       jj_consume_token(DOTASSIGN);
1504                         {if (true) return VariableDeclaration.DOT_EQUAL;}
1505       break;
1506     case TILDEEQUAL:
1507       jj_consume_token(TILDEEQUAL);
1508                         {if (true) return VariableDeclaration.TILDE_EQUAL;}
1509       break;
1510     default:
1511       jj_la1[29] = jj_gen;
1512       jj_consume_token(-1);
1513       throw new ParseException();
1514     }
1515     throw new Error("Missing return statement in function");
1516   }
1517
1518   static final public Expression ConditionalExpression() throws ParseException {
1519   final Expression expr;
1520   Expression expr2 = null;
1521   Expression expr3 = null;
1522     expr = ConditionalOrExpression();
1523     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1524     case HOOK:
1525       jj_consume_token(HOOK);
1526       expr2 = Expression();
1527       jj_consume_token(COLON);
1528       expr3 = ConditionalExpression();
1529       break;
1530     default:
1531       jj_la1[30] = jj_gen;
1532       ;
1533     }
1534   if (expr3 == null) {
1535     {if (true) return expr;}
1536   }
1537   {if (true) return new ConditionalExpression(expr,expr2,expr3);}
1538     throw new Error("Missing return statement in function");
1539   }
1540
1541   static final public Expression ConditionalOrExpression() throws ParseException {
1542   Expression expr,expr2;
1543   int operator;
1544     expr = ConditionalAndExpression();
1545     label_8:
1546     while (true) {
1547       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1548       case OR_OR:
1549       case _ORL:
1550         ;
1551         break;
1552       default:
1553         jj_la1[31] = jj_gen;
1554         break label_8;
1555       }
1556       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1557       case OR_OR:
1558         jj_consume_token(OR_OR);
1559                  operator = OperatorIds.OR_OR;
1560         break;
1561       case _ORL:
1562         jj_consume_token(_ORL);
1563                  operator = OperatorIds.ORL;
1564         break;
1565       default:
1566         jj_la1[32] = jj_gen;
1567         jj_consume_token(-1);
1568         throw new ParseException();
1569       }
1570       expr2 = ConditionalAndExpression();
1571       expr = new BinaryExpression(expr,expr2,operator);
1572     }
1573    {if (true) return expr;}
1574     throw new Error("Missing return statement in function");
1575   }
1576
1577   static final public Expression ConditionalAndExpression() throws ParseException {
1578   Expression expr,expr2;
1579   int operator;
1580     expr = ConcatExpression();
1581     label_9:
1582     while (true) {
1583       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1584       case AND_AND:
1585       case _ANDL:
1586         ;
1587         break;
1588       default:
1589         jj_la1[33] = jj_gen;
1590         break label_9;
1591       }
1592       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1593       case AND_AND:
1594         jj_consume_token(AND_AND);
1595                 operator = OperatorIds.AND_AND;
1596         break;
1597       case _ANDL:
1598         jj_consume_token(_ANDL);
1599                 operator = OperatorIds.ANDL;
1600         break;
1601       default:
1602         jj_la1[34] = jj_gen;
1603         jj_consume_token(-1);
1604         throw new ParseException();
1605       }
1606       expr2 = ConcatExpression();
1607                                expr = new BinaryExpression(expr,expr2,operator);
1608     }
1609    {if (true) return expr;}
1610     throw new Error("Missing return statement in function");
1611   }
1612
1613   static final public Expression ConcatExpression() throws ParseException {
1614   Expression expr,expr2;
1615     expr = InclusiveOrExpression();
1616     label_10:
1617     while (true) {
1618       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1619       case DOT:
1620         ;
1621         break;
1622       default:
1623         jj_la1[35] = jj_gen;
1624         break label_10;
1625       }
1626       jj_consume_token(DOT);
1627       expr2 = InclusiveOrExpression();
1628      expr = new BinaryExpression(expr,expr2,OperatorIds.DOT);
1629     }
1630    {if (true) return expr;}
1631     throw new Error("Missing return statement in function");
1632   }
1633
1634   static final public Expression InclusiveOrExpression() throws ParseException {
1635   Expression expr,expr2;
1636     expr = ExclusiveOrExpression();
1637     label_11:
1638     while (true) {
1639       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1640       case BIT_OR:
1641         ;
1642         break;
1643       default:
1644         jj_la1[36] = jj_gen;
1645         break label_11;
1646       }
1647       jj_consume_token(BIT_OR);
1648       expr2 = ExclusiveOrExpression();
1649     expr = new BinaryExpression(expr,expr2,OperatorIds.OR);
1650     }
1651    {if (true) return expr;}
1652     throw new Error("Missing return statement in function");
1653   }
1654
1655   static final public Expression ExclusiveOrExpression() throws ParseException {
1656   Expression expr,expr2;
1657     expr = AndExpression();
1658     label_12:
1659     while (true) {
1660       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1661       case XOR:
1662         ;
1663         break;
1664       default:
1665         jj_la1[37] = jj_gen;
1666         break label_12;
1667       }
1668       jj_consume_token(XOR);
1669       expr2 = AndExpression();
1670      expr = new BinaryExpression(expr,expr2,OperatorIds.XOR);
1671     }
1672    {if (true) return expr;}
1673     throw new Error("Missing return statement in function");
1674   }
1675
1676   static final public Expression AndExpression() throws ParseException {
1677   Expression expr,expr2;
1678     expr = EqualityExpression();
1679     label_13:
1680     while (true) {
1681       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1682       case BIT_AND:
1683         ;
1684         break;
1685       default:
1686         jj_la1[38] = jj_gen;
1687         break label_13;
1688       }
1689       jj_consume_token(BIT_AND);
1690       expr2 = EqualityExpression();
1691      expr = new BinaryExpression(expr,expr2,OperatorIds.AND);
1692     }
1693    {if (true) return expr;}
1694     throw new Error("Missing return statement in function");
1695   }
1696
1697   static final public Expression EqualityExpression() throws ParseException {
1698   Expression expr,expr2;
1699   int operator;
1700   Token token;
1701     expr = RelationalExpression();
1702     label_14:
1703     while (true) {
1704       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1705       case EQUAL_EQUAL:
1706       case NOT_EQUAL:
1707       case DIF:
1708       case BANGDOUBLEEQUAL:
1709       case TRIPLEEQUAL:
1710         ;
1711         break;
1712       default:
1713         jj_la1[39] = jj_gen;
1714         break label_14;
1715       }
1716       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1717       case EQUAL_EQUAL:
1718         token = jj_consume_token(EQUAL_EQUAL);
1719                                   operator = OperatorIds.EQUAL_EQUAL;
1720         break;
1721       case DIF:
1722         token = jj_consume_token(DIF);
1723                                   operator = OperatorIds.DIF;
1724         break;
1725       case NOT_EQUAL:
1726         token = jj_consume_token(NOT_EQUAL);
1727                                   operator = OperatorIds.DIF;
1728         break;
1729       case BANGDOUBLEEQUAL:
1730         token = jj_consume_token(BANGDOUBLEEQUAL);
1731                                   operator = OperatorIds.BANG_EQUAL_EQUAL;
1732         break;
1733       case TRIPLEEQUAL:
1734         token = jj_consume_token(TRIPLEEQUAL);
1735                                   operator = OperatorIds.EQUAL_EQUAL_EQUAL;
1736         break;
1737       default:
1738         jj_la1[40] = jj_gen;
1739         jj_consume_token(-1);
1740         throw new ParseException();
1741       }
1742       try {
1743         expr2 = RelationalExpression();
1744       } catch (ParseException e) {
1745     if (errorMessage != null) {
1746       {if (true) throw e;}
1747     }
1748     errorMessage = "unexpected token : '"+ e.currentToken.next.image +"', expression expected";
1749     errorLevel   = ERROR;
1750     errorStart = token.sourceEnd +1;
1751     errorEnd   = token.sourceEnd +1;
1752     expr2 = new ConstantIdentifier(SYNTAX_ERROR_CHAR,token.sourceEnd +1,token.sourceEnd +1);
1753     processParseExceptionDebug(e);
1754       }
1755     expr = new BinaryExpression(expr,expr2,operator);
1756     }
1757    {if (true) return expr;}
1758     throw new Error("Missing return statement in function");
1759   }
1760
1761   static final public Expression RelationalExpression() throws ParseException {
1762   Expression expr,expr2;
1763   int operator;
1764     expr = ShiftExpression();
1765     label_15:
1766     while (true) {
1767       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1768       case GT:
1769       case LT:
1770       case LE:
1771       case GE:
1772         ;
1773         break;
1774       default:
1775         jj_la1[41] = jj_gen;
1776         break label_15;
1777       }
1778       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1779       case LT:
1780         jj_consume_token(LT);
1781           operator = OperatorIds.LESS;
1782         break;
1783       case GT:
1784         jj_consume_token(GT);
1785           operator = OperatorIds.GREATER;
1786         break;
1787       case LE:
1788         jj_consume_token(LE);
1789           operator = OperatorIds.LESS_EQUAL;
1790         break;
1791       case GE:
1792         jj_consume_token(GE);
1793           operator = OperatorIds.GREATER_EQUAL;
1794         break;
1795       default:
1796         jj_la1[42] = jj_gen;
1797         jj_consume_token(-1);
1798         throw new ParseException();
1799       }
1800       expr2 = ShiftExpression();
1801    expr = new BinaryExpression(expr,expr2,operator);
1802     }
1803    {if (true) return expr;}
1804     throw new Error("Missing return statement in function");
1805   }
1806
1807   static final public Expression ShiftExpression() throws ParseException {
1808   Expression expr,expr2;
1809   int operator;
1810     expr = AdditiveExpression();
1811     label_16:
1812     while (true) {
1813       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1814       case LSHIFT:
1815       case RSIGNEDSHIFT:
1816       case RUNSIGNEDSHIFT:
1817         ;
1818         break;
1819       default:
1820         jj_la1[43] = jj_gen;
1821         break label_16;
1822       }
1823       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1824       case LSHIFT:
1825         jj_consume_token(LSHIFT);
1826                       operator = OperatorIds.LEFT_SHIFT;
1827         break;
1828       case RSIGNEDSHIFT:
1829         jj_consume_token(RSIGNEDSHIFT);
1830                       operator = OperatorIds.RIGHT_SHIFT;
1831         break;
1832       case RUNSIGNEDSHIFT:
1833         jj_consume_token(RUNSIGNEDSHIFT);
1834                       operator = OperatorIds.UNSIGNED_RIGHT_SHIFT;
1835         break;
1836       default:
1837         jj_la1[44] = jj_gen;
1838         jj_consume_token(-1);
1839         throw new ParseException();
1840       }
1841       expr2 = AdditiveExpression();
1842    expr = new BinaryExpression(expr,expr2,operator);
1843     }
1844    {if (true) return expr;}
1845     throw new Error("Missing return statement in function");
1846   }
1847
1848   static final public Expression AdditiveExpression() throws ParseException {
1849   Expression expr,expr2;
1850   int operator;
1851     expr = MultiplicativeExpression();
1852     label_17:
1853     while (true) {
1854       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1855       case PLUS:
1856       case MINUS:
1857         ;
1858         break;
1859       default:
1860         jj_la1[45] = jj_gen;
1861         break label_17;
1862       }
1863       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1864       case PLUS:
1865         jj_consume_token(PLUS);
1866                 operator = OperatorIds.PLUS;
1867         break;
1868       case MINUS:
1869         jj_consume_token(MINUS);
1870                 operator = OperatorIds.MINUS;
1871         break;
1872       default:
1873         jj_la1[46] = jj_gen;
1874         jj_consume_token(-1);
1875         throw new ParseException();
1876       }
1877       expr2 = MultiplicativeExpression();
1878    expr = new BinaryExpression(expr,expr2,operator);
1879     }
1880    {if (true) return expr;}
1881     throw new Error("Missing return statement in function");
1882   }
1883
1884   static final public Expression MultiplicativeExpression() throws ParseException {
1885   Expression expr,expr2;
1886   int operator;
1887     try {
1888       expr = UnaryExpression();
1889     } catch (ParseException e) {
1890     if (errorMessage != null) {if (true) throw e;}
1891     errorMessage = "unexpected token '"+e.currentToken.next.image+"'";
1892     errorLevel   = ERROR;
1893     errorStart = PHPParser.token.sourceStart;
1894     errorEnd   = PHPParser.token.sourceEnd;
1895     {if (true) throw e;}
1896     }
1897     label_18:
1898     while (true) {
1899       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1900       case STAR:
1901       case SLASH:
1902       case REMAINDER:
1903         ;
1904         break;
1905       default:
1906         jj_la1[47] = jj_gen;
1907         break label_18;
1908       }
1909       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1910       case STAR:
1911         jj_consume_token(STAR);
1912                    operator = OperatorIds.MULTIPLY;
1913         break;
1914       case SLASH:
1915         jj_consume_token(SLASH);
1916                    operator = OperatorIds.DIVIDE;
1917         break;
1918       case REMAINDER:
1919         jj_consume_token(REMAINDER);
1920                    operator = OperatorIds.REMAINDER;
1921         break;
1922       default:
1923         jj_la1[48] = jj_gen;
1924         jj_consume_token(-1);
1925         throw new ParseException();
1926       }
1927       expr2 = UnaryExpression();
1928      expr = new BinaryExpression(expr,expr2,operator);
1929     }
1930    {if (true) return expr;}
1931     throw new Error("Missing return statement in function");
1932   }
1933
1934 /**
1935  * An unary expression starting with @, & or nothing
1936  */
1937   static final public Expression UnaryExpression() throws ParseException {
1938   final Expression expr;
1939     /* <BIT_AND> expr = UnaryExpressionNoPrefix()             //why did I had that ?
1940       {return new PrefixedUnaryExpression(expr,OperatorIds.AND,pos);}
1941     |      */
1942       expr = AtNotTildeUnaryExpression();
1943                                       {if (true) return expr;}
1944     throw new Error("Missing return statement in function");
1945   }
1946
1947   static final public Expression AtNotTildeUnaryExpression() throws ParseException {
1948   final Expression expr;
1949   final Token token;
1950     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1951     case AT:
1952       token = jj_consume_token(AT);
1953       expr = AtNotTildeUnaryExpression();
1954    {if (true) return new PrefixedUnaryExpression(expr,OperatorIds.AT,token.sourceStart);}
1955       break;
1956     case TILDE:
1957       token = jj_consume_token(TILDE);
1958       expr = AtNotTildeUnaryExpression();
1959    {if (true) return new PrefixedUnaryExpression(expr,OperatorIds.TWIDDLE,token.sourceStart);}
1960       break;
1961     case BANG:
1962       token = jj_consume_token(BANG);
1963       expr = AtNotUnaryExpression();
1964    {if (true) return new PrefixedUnaryExpression(expr,OperatorIds.NOT,token.sourceStart);}
1965       break;
1966     case ARRAY:
1967     case NEW:
1968     case NULL:
1969     case TRUE:
1970     case FALSE:
1971     case PLUS_PLUS:
1972     case MINUS_MINUS:
1973     case PLUS:
1974     case MINUS:
1975     case BIT_AND:
1976     case INTEGER_LITERAL:
1977     case FLOATING_POINT_LITERAL:
1978     case STRING_LITERAL:
1979     case DOUBLEQUOTE:
1980     case DOLLAR:
1981     case IDENTIFIER:
1982     case LPAREN:
1983       expr = UnaryExpressionNoPrefix();
1984    {if (true) return expr;}
1985       break;
1986     default:
1987       jj_la1[49] = jj_gen;
1988       jj_consume_token(-1);
1989       throw new ParseException();
1990     }
1991     throw new Error("Missing return statement in function");
1992   }
1993
1994 /**
1995  * An expression prefixed (or not) by one or more @ and !.
1996  * @return the expression
1997  */
1998   static final public Expression AtNotUnaryExpression() throws ParseException {
1999   final Expression expr;
2000   final Token token;
2001     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2002     case AT:
2003       token = jj_consume_token(AT);
2004       expr = AtNotUnaryExpression();
2005    {if (true) return new PrefixedUnaryExpression(expr,OperatorIds.AT,token.sourceStart);}
2006       break;
2007     case BANG:
2008       token = jj_consume_token(BANG);
2009       expr = AtNotUnaryExpression();
2010    {if (true) return new PrefixedUnaryExpression(expr,OperatorIds.NOT,token.sourceStart);}
2011       break;
2012     case ARRAY:
2013     case NEW:
2014     case NULL:
2015     case TRUE:
2016     case FALSE:
2017     case PLUS_PLUS:
2018     case MINUS_MINUS:
2019     case PLUS:
2020     case MINUS:
2021     case BIT_AND:
2022     case INTEGER_LITERAL:
2023     case FLOATING_POINT_LITERAL:
2024     case STRING_LITERAL:
2025     case DOUBLEQUOTE:
2026     case DOLLAR:
2027     case IDENTIFIER:
2028     case LPAREN:
2029       expr = UnaryExpressionNoPrefix();
2030    {if (true) return expr;}
2031       break;
2032     default:
2033       jj_la1[50] = jj_gen;
2034       jj_consume_token(-1);
2035       throw new ParseException();
2036     }
2037     throw new Error("Missing return statement in function");
2038   }
2039
2040   static final public Expression UnaryExpressionNoPrefix() throws ParseException {
2041   final Expression expr;
2042   final Token token;
2043     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2044     case PLUS:
2045       token = jj_consume_token(PLUS);
2046       expr = AtNotTildeUnaryExpression();
2047                                                        {if (true) return new PrefixedUnaryExpression(expr,
2048                                                                                      OperatorIds.PLUS,
2049                                                                                      token.sourceStart);}
2050       break;
2051     case MINUS:
2052       token = jj_consume_token(MINUS);
2053       expr = AtNotTildeUnaryExpression();
2054                                                        {if (true) return new PrefixedUnaryExpression(expr,
2055                                                                                      OperatorIds.MINUS,
2056                                                                                      token.sourceStart);}
2057       break;
2058     case PLUS_PLUS:
2059     case MINUS_MINUS:
2060       expr = PreIncDecExpression();
2061    {if (true) return expr;}
2062       break;
2063     case ARRAY:
2064     case NEW:
2065     case NULL:
2066     case TRUE:
2067     case FALSE:
2068     case BIT_AND:
2069     case INTEGER_LITERAL:
2070     case FLOATING_POINT_LITERAL:
2071     case STRING_LITERAL:
2072     case DOUBLEQUOTE:
2073     case DOLLAR:
2074     case IDENTIFIER:
2075     case LPAREN:
2076       expr = UnaryExpressionNotPlusMinus();
2077    {if (true) return expr;}
2078       break;
2079     default:
2080       jj_la1[51] = jj_gen;
2081       jj_consume_token(-1);
2082       throw new ParseException();
2083     }
2084     throw new Error("Missing return statement in function");
2085   }
2086
2087   static final public Expression PreIncDecExpression() throws ParseException {
2088 final Expression expr;
2089 final int operator;
2090 final Token token;
2091     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2092     case PLUS_PLUS:
2093       token = jj_consume_token(PLUS_PLUS);
2094                              operator = OperatorIds.PLUS_PLUS;
2095       break;
2096     case MINUS_MINUS:
2097       token = jj_consume_token(MINUS_MINUS);
2098                              operator = OperatorIds.MINUS_MINUS;
2099       break;
2100     default:
2101       jj_la1[52] = jj_gen;
2102       jj_consume_token(-1);
2103       throw new ParseException();
2104     }
2105     expr = PrimaryExpression();
2106    {if (true) return new PrefixedUnaryExpression(expr,operator,token.sourceStart);}
2107     throw new Error("Missing return statement in function");
2108   }
2109
2110   static final public Expression UnaryExpressionNotPlusMinus() throws ParseException {
2111   final Expression expr;
2112     if (jj_2_3(2147483647)) {
2113       expr = CastExpression();
2114                                    {if (true) return expr;}
2115     } else {
2116       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2117       case ARRAY:
2118       case NEW:
2119       case BIT_AND:
2120       case DOLLAR:
2121       case IDENTIFIER:
2122         expr = PostfixExpression();
2123                                    {if (true) return expr;}
2124         break;
2125       case NULL:
2126       case TRUE:
2127       case FALSE:
2128       case INTEGER_LITERAL:
2129       case FLOATING_POINT_LITERAL:
2130       case STRING_LITERAL:
2131       case DOUBLEQUOTE:
2132         expr = Literal();
2133                                    {if (true) return expr;}
2134         break;
2135       case LPAREN:
2136         jj_consume_token(LPAREN);
2137         expr = Expression();
2138         try {
2139           jj_consume_token(RPAREN);
2140         } catch (ParseException e) {
2141     errorMessage = "')' expected";
2142     errorLevel   = ERROR;
2143     errorStart   = expr.sourceEnd +1;
2144     errorEnd     = expr.sourceEnd +1;
2145     processParseExceptionDebug(e);
2146         }
2147    {if (true) return expr;}
2148         break;
2149       default:
2150         jj_la1[53] = jj_gen;
2151         jj_consume_token(-1);
2152         throw new ParseException();
2153       }
2154     }
2155     throw new Error("Missing return statement in function");
2156   }
2157
2158   static final public CastExpression CastExpression() throws ParseException {
2159 final ConstantIdentifier type;
2160 final Expression expr;
2161 final Token token,token1;
2162     token1 = jj_consume_token(LPAREN);
2163     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2164     case STRING:
2165     case OBJECT:
2166     case BOOL:
2167     case BOOLEAN:
2168     case REAL:
2169     case DOUBLE:
2170     case FLOAT:
2171     case INT:
2172     case INTEGER:
2173       type = Type();
2174       break;
2175     case ARRAY:
2176       token = jj_consume_token(ARRAY);
2177                        type = new ConstantIdentifier(token);
2178       break;
2179     default:
2180       jj_la1[54] = jj_gen;
2181       jj_consume_token(-1);
2182       throw new ParseException();
2183     }
2184     jj_consume_token(RPAREN);
2185     expr = UnaryExpression();
2186    {if (true) return new CastExpression(type,expr,token1.sourceStart,expr.sourceEnd);}
2187     throw new Error("Missing return statement in function");
2188   }
2189
2190   static final public Expression PostfixExpression() throws ParseException {
2191   final Expression expr;
2192   int operator = -1;
2193   Token token = null;
2194     expr = PrimaryExpression();
2195     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2196     case PLUS_PLUS:
2197     case MINUS_MINUS:
2198       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2199       case PLUS_PLUS:
2200         token = jj_consume_token(PLUS_PLUS);
2201                              operator = OperatorIds.PLUS_PLUS;
2202         break;
2203       case MINUS_MINUS:
2204         token = jj_consume_token(MINUS_MINUS);
2205                              operator = OperatorIds.MINUS_MINUS;
2206         break;
2207       default:
2208         jj_la1[55] = jj_gen;
2209         jj_consume_token(-1);
2210         throw new ParseException();
2211       }
2212       break;
2213     default:
2214       jj_la1[56] = jj_gen;
2215       ;
2216     }
2217     if (operator == -1) {
2218       {if (true) return expr;}
2219     }
2220     {if (true) return new PostfixedUnaryExpression(expr,operator,token.sourceEnd);}
2221     throw new Error("Missing return statement in function");
2222   }
2223
2224   static final public Expression PrimaryExpression() throws ParseException {
2225   Expression expr;
2226   Token token = null;
2227     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2228     case NEW:
2229     case BIT_AND:
2230     case DOLLAR:
2231     case IDENTIFIER:
2232       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2233       case BIT_AND:
2234         token = jj_consume_token(BIT_AND);
2235         break;
2236       default:
2237         jj_la1[57] = jj_gen;
2238         ;
2239       }
2240       expr = refPrimaryExpression(token);
2241    {if (true) return expr;}
2242       break;
2243     case ARRAY:
2244       expr = ArrayDeclarator();
2245    {if (true) return expr;}
2246       break;
2247     default:
2248       jj_la1[58] = jj_gen;
2249       jj_consume_token(-1);
2250       throw new ParseException();
2251     }
2252     throw new Error("Missing return statement in function");
2253   }
2254
2255   static final public Expression refPrimaryExpression(final Token reference) throws ParseException {
2256   Expression expr;
2257   Expression expr2 = null;
2258   final Token identifier;
2259     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2260     case IDENTIFIER:
2261       identifier = jj_consume_token(IDENTIFIER);
2262     expr = new ConstantIdentifier(identifier);
2263       label_19:
2264       while (true) {
2265         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2266         case STATICCLASSACCESS:
2267           ;
2268           break;
2269         default:
2270           jj_la1[59] = jj_gen;
2271           break label_19;
2272         }
2273         jj_consume_token(STATICCLASSACCESS);
2274         expr2 = ClassIdentifier();
2275      expr = new ClassAccess(expr,
2276                             expr2,
2277                             ClassAccess.STATIC);
2278       }
2279       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2280       case LPAREN:
2281         expr2 = Arguments(expr);
2282         break;
2283       default:
2284         jj_la1[60] = jj_gen;
2285         ;
2286       }
2287     if (expr2 == null) {
2288       if (reference != null) {
2289         ParseException e = generateParseException();
2290         errorMessage = "you cannot use a constant by reference";
2291         errorLevel   = ERROR;
2292         errorStart   = reference.sourceStart;
2293         errorEnd     = reference.sourceEnd;
2294         processParseExceptionDebug(e);
2295       }
2296       {if (true) return expr;}
2297     }
2298     {if (true) return expr2;}
2299       break;
2300     case DOLLAR:
2301       expr = VariableDeclaratorId();
2302       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2303       case LPAREN:
2304         expr = Arguments(expr);
2305         break;
2306       default:
2307         jj_la1[61] = jj_gen;
2308         ;
2309       }
2310    {if (true) return expr;}
2311       break;
2312     case NEW:
2313       token = jj_consume_token(NEW);
2314       expr = ClassIdentifier();
2315     int start;
2316     if (reference == null) {
2317       start = token.sourceStart;
2318     } else {
2319       start = reference.sourceStart;
2320     }
2321     expr = new ClassInstantiation(expr,
2322                                   reference != null,
2323                                   start);
2324       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2325       case LPAREN:
2326         expr = Arguments(expr);
2327         break;
2328       default:
2329         jj_la1[62] = jj_gen;
2330         ;
2331       }
2332    {if (true) return expr;}
2333       break;
2334     default:
2335       jj_la1[63] = jj_gen;
2336       jj_consume_token(-1);
2337       throw new ParseException();
2338     }
2339     throw new Error("Missing return statement in function");
2340   }
2341
2342 /**
2343  * An array declarator.
2344  * array(vars)
2345  * @return an array
2346  */
2347   static final public ArrayInitializer ArrayDeclarator() throws ParseException {
2348   final ArrayVariableDeclaration[] vars;
2349   final Token token;
2350     token = jj_consume_token(ARRAY);
2351     vars = ArrayInitializer();
2352    {if (true) return new ArrayInitializer(vars,
2353                                token.sourceStart,
2354                                PHPParser.token.sourceEnd);}
2355     throw new Error("Missing return statement in function");
2356   }
2357
2358   static final public Expression ClassIdentifier() throws ParseException {
2359   final Expression expr;
2360   final Token token;
2361     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2362     case IDENTIFIER:
2363       token = jj_consume_token(IDENTIFIER);
2364                                  {if (true) return new ConstantIdentifier(token);}
2365       break;
2366     case STRING:
2367     case OBJECT:
2368     case BOOL:
2369     case BOOLEAN:
2370     case REAL:
2371     case DOUBLE:
2372     case FLOAT:
2373     case INT:
2374     case INTEGER:
2375       expr = Type();
2376                                  {if (true) return expr;}
2377       break;
2378     case DOLLAR:
2379       expr = VariableDeclaratorId();
2380                                  {if (true) return expr;}
2381       break;
2382     default:
2383       jj_la1[64] = jj_gen;
2384       jj_consume_token(-1);
2385       throw new ParseException();
2386     }
2387     throw new Error("Missing return statement in function");
2388   }
2389
2390 /**
2391  * Used by Variabledeclaratorid and primarysuffix
2392  */
2393   static final public AbstractVariable VariableSuffix(final AbstractVariable prefix) throws ParseException {
2394   Expression expression = null;
2395   final Token classAccessToken,lbrace,rbrace;
2396   Token token;
2397   int pos;
2398     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2399     case CLASSACCESS:
2400       classAccessToken = jj_consume_token(CLASSACCESS);
2401       try {
2402         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2403         case LBRACE:
2404           lbrace = jj_consume_token(LBRACE);
2405           expression = Expression();
2406           rbrace = jj_consume_token(RBRACE);
2407                  expression = new Variable(expression,
2408                                            lbrace.sourceStart,
2409                                            rbrace.sourceEnd);
2410           break;
2411         case IDENTIFIER:
2412           token = jj_consume_token(IDENTIFIER);
2413          expression = new ConstantIdentifier(token.image,token.sourceStart,token.sourceEnd);
2414           break;
2415         case DOLLAR:
2416           expression = Variable();
2417           break;
2418         default:
2419           jj_la1[65] = jj_gen;
2420           jj_consume_token(-1);
2421           throw new ParseException();
2422         }
2423       } catch (ParseException e) {
2424     errorMessage = "unexpected token : '"+ e.currentToken.next.image +"', function call or field access expected";
2425     errorLevel   = ERROR;
2426     errorStart = classAccessToken.sourceEnd +1;
2427     errorEnd   = classAccessToken.sourceEnd +1;
2428     processParseExceptionDebug(e);
2429       }
2430    {if (true) return new ClassAccess(prefix,
2431                           expression,
2432                           ClassAccess.NORMAL);}
2433       break;
2434     case LBRACKET:
2435       token = jj_consume_token(LBRACKET);
2436                       pos = token.sourceEnd+1;
2437       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2438       case ARRAY:
2439       case LIST:
2440       case PRINT:
2441       case NEW:
2442       case NULL:
2443       case TRUE:
2444       case FALSE:
2445       case STRING:
2446       case OBJECT:
2447       case BOOL:
2448       case BOOLEAN:
2449       case REAL:
2450       case DOUBLE:
2451       case FLOAT:
2452       case INT:
2453       case INTEGER:
2454       case AT:
2455       case BANG:
2456       case TILDE:
2457       case PLUS_PLUS:
2458       case MINUS_MINUS:
2459       case PLUS:
2460       case MINUS:
2461       case BIT_AND:
2462       case INTEGER_LITERAL:
2463       case FLOATING_POINT_LITERAL:
2464       case STRING_LITERAL:
2465       case DOUBLEQUOTE:
2466       case DOLLAR:
2467       case IDENTIFIER:
2468       case LPAREN:
2469         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2470         case ARRAY:
2471         case LIST:
2472         case PRINT:
2473         case NEW:
2474         case NULL:
2475         case TRUE:
2476         case FALSE:
2477         case AT:
2478         case BANG:
2479         case TILDE:
2480         case PLUS_PLUS:
2481         case MINUS_MINUS:
2482         case PLUS:
2483         case MINUS:
2484         case BIT_AND:
2485         case INTEGER_LITERAL:
2486         case FLOATING_POINT_LITERAL:
2487         case STRING_LITERAL:
2488         case DOUBLEQUOTE:
2489         case DOLLAR:
2490         case IDENTIFIER:
2491         case LPAREN:
2492           expression = Expression();
2493                                 pos = expression.sourceEnd+1;
2494           break;
2495         case STRING:
2496         case OBJECT:
2497         case BOOL:
2498         case BOOLEAN:
2499         case REAL:
2500         case DOUBLE:
2501         case FLOAT:
2502         case INT:
2503         case INTEGER:
2504           expression = Type();
2505                                 pos = expression.sourceEnd+1;
2506           break;
2507         default:
2508           jj_la1[66] = jj_gen;
2509           jj_consume_token(-1);
2510           throw new ParseException();
2511         }
2512         break;
2513       default:
2514         jj_la1[67] = jj_gen;
2515         ;
2516       }
2517       try {
2518         token = jj_consume_token(RBRACKET);
2519      pos = token.sourceEnd;
2520       } catch (ParseException e) {
2521     errorMessage = "']' expected";
2522     errorLevel   = ERROR;
2523     errorStart = pos;
2524     errorEnd   = pos;
2525     processParseExceptionDebug(e);
2526       }
2527    {if (true) return new ArrayDeclarator(prefix,expression,pos);}
2528       break;
2529     case LBRACE:
2530       token = jj_consume_token(LBRACE);
2531                     pos = token.sourceEnd+1;
2532       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2533       case ARRAY:
2534       case LIST:
2535       case PRINT:
2536       case NEW:
2537       case NULL:
2538       case TRUE:
2539       case FALSE:
2540       case STRING:
2541       case OBJECT:
2542       case BOOL:
2543       case BOOLEAN:
2544       case REAL:
2545       case DOUBLE:
2546       case FLOAT:
2547       case INT:
2548       case INTEGER:
2549       case AT:
2550       case BANG:
2551       case TILDE:
2552       case PLUS_PLUS:
2553       case MINUS_MINUS:
2554       case PLUS:
2555       case MINUS:
2556       case BIT_AND:
2557       case INTEGER_LITERAL:
2558       case FLOATING_POINT_LITERAL:
2559       case STRING_LITERAL:
2560       case DOUBLEQUOTE:
2561       case DOLLAR:
2562       case IDENTIFIER:
2563       case LPAREN:
2564         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2565         case ARRAY:
2566         case LIST:
2567         case PRINT:
2568         case NEW:
2569         case NULL:
2570         case TRUE:
2571         case FALSE:
2572         case AT:
2573         case BANG:
2574         case TILDE:
2575         case PLUS_PLUS:
2576         case MINUS_MINUS:
2577         case PLUS:
2578         case MINUS:
2579         case BIT_AND:
2580         case INTEGER_LITERAL:
2581         case FLOATING_POINT_LITERAL:
2582         case STRING_LITERAL:
2583         case DOUBLEQUOTE:
2584         case DOLLAR:
2585         case IDENTIFIER:
2586         case LPAREN:
2587           expression = Expression();
2588                                 pos = expression.sourceEnd+1;
2589           break;
2590         case STRING:
2591         case OBJECT:
2592         case BOOL:
2593         case BOOLEAN:
2594         case REAL:
2595         case DOUBLE:
2596         case FLOAT:
2597         case INT:
2598         case INTEGER:
2599           expression = Type();
2600                                 pos = expression.sourceEnd+1;
2601           break;
2602         default:
2603           jj_la1[68] = jj_gen;
2604           jj_consume_token(-1);
2605           throw new ParseException();
2606         }
2607         break;
2608       default:
2609         jj_la1[69] = jj_gen;
2610         ;
2611       }
2612       try {
2613         token = jj_consume_token(RBRACE);
2614      pos = token.sourceEnd;
2615       } catch (ParseException e) {
2616     errorMessage = "']' expected";
2617     errorLevel   = ERROR;
2618     errorStart = pos;
2619     errorEnd   = pos;
2620     processParseExceptionDebug(e);
2621       }
2622    {if (true) return new ArrayDeclarator(prefix,expression,pos);}
2623       break;
2624     default:
2625       jj_la1[70] = jj_gen;
2626       jj_consume_token(-1);
2627       throw new ParseException();
2628     }
2629     throw new Error("Missing return statement in function");
2630   }
2631
2632   static final public Literal Literal() throws ParseException {
2633   final Token token;
2634   StringLiteral literal;
2635     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2636     case INTEGER_LITERAL:
2637       token = jj_consume_token(INTEGER_LITERAL);
2638                                     {if (true) return new NumberLiteral(token);}
2639       break;
2640     case FLOATING_POINT_LITERAL:
2641       token = jj_consume_token(FLOATING_POINT_LITERAL);
2642                                     {if (true) return new NumberLiteral(token);}
2643       break;
2644     case STRING_LITERAL:
2645       token = jj_consume_token(STRING_LITERAL);
2646                                     {if (true) return new StringLiteral(token);}
2647       break;
2648     case TRUE:
2649       token = jj_consume_token(TRUE);
2650                                     {if (true) return new TrueLiteral(token);}
2651       break;
2652     case FALSE:
2653       token = jj_consume_token(FALSE);
2654                                     {if (true) return new FalseLiteral(token);}
2655       break;
2656     case NULL:
2657       token = jj_consume_token(NULL);
2658                                     {if (true) return new NullLiteral(token);}
2659       break;
2660     case DOUBLEQUOTE:
2661       literal = evaluableString();
2662                                       {if (true) return literal;}
2663       break;
2664     default:
2665       jj_la1[71] = jj_gen;
2666       jj_consume_token(-1);
2667       throw new ParseException();
2668     }
2669     throw new Error("Missing return statement in function");
2670   }
2671
2672   static final public StringLiteral evaluableString() throws ParseException {
2673   ArrayList list = new ArrayList();
2674   Token start,end;
2675   Token token,lbrace,rbrace;
2676   AbstractVariable var;
2677   Expression expr;
2678     start = jj_consume_token(DOUBLEQUOTE);
2679     label_20:
2680     while (true) {
2681       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2682       case DOLLARS:
2683         ;
2684         break;
2685       default:
2686         jj_la1[72] = jj_gen;
2687         break label_20;
2688       }
2689       jj_consume_token(DOLLARS);
2690       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2691       case IDENTIFIER:
2692         token = jj_consume_token(IDENTIFIER);
2693                               list.add(new Variable(token.image,
2694                                                     token.sourceStart,
2695                                                     token.sourceEnd));
2696         break;
2697       case LBRACE1:
2698         lbrace = jj_consume_token(LBRACE1);
2699         token = jj_consume_token(ID);
2700           list.add(new Variable(token.image,
2701                                 token.sourceStart,
2702                                 token.sourceEnd));
2703         rbrace = jj_consume_token(RBRACE1);
2704         break;
2705       default:
2706         jj_la1[73] = jj_gen;
2707         jj_consume_token(-1);
2708         throw new ParseException();
2709       }
2710     }
2711     end = jj_consume_token(DOUBLEQUOTE2);
2712   AbstractVariable[] vars = new AbstractVariable[list.size()];
2713   list.toArray(vars);
2714   {if (true) return new StringLiteral(SimpleCharStream.currentBuffer.substring(start.sourceEnd,end.sourceStart),
2715                            start.sourceStart,
2716                            end.sourceEnd,
2717                            vars);}
2718     throw new Error("Missing return statement in function");
2719   }
2720
2721   static final public FunctionCall Arguments(final Expression func) throws ParseException {
2722 Expression[] args = null;
2723 final Token token;
2724     jj_consume_token(LPAREN);
2725     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2726     case ARRAY:
2727     case LIST:
2728     case PRINT:
2729     case NEW:
2730     case NULL:
2731     case TRUE:
2732     case FALSE:
2733     case AT:
2734     case BANG:
2735     case TILDE:
2736     case PLUS_PLUS:
2737     case MINUS_MINUS:
2738     case PLUS:
2739     case MINUS:
2740     case BIT_AND:
2741     case INTEGER_LITERAL:
2742     case FLOATING_POINT_LITERAL:
2743     case STRING_LITERAL:
2744     case DOUBLEQUOTE:
2745     case DOLLAR:
2746     case IDENTIFIER:
2747     case LPAREN:
2748       args = ArgumentList();
2749       break;
2750     default:
2751       jj_la1[74] = jj_gen;
2752       ;
2753     }
2754     try {
2755       token = jj_consume_token(RPAREN);
2756      {if (true) return new FunctionCall(func,args,token.sourceEnd);}
2757     } catch (ParseException e) {
2758     errorMessage = "unexpected token : '"+ e.currentToken.next.image +"', ')' expected to close the argument list";
2759     errorLevel   = ERROR;
2760     errorStart = args[args.length-1].sourceEnd+1;
2761     errorEnd   = args[args.length-1].sourceEnd+1;
2762     processParseExceptionDebug(e);
2763     }
2764    {if (true) return new FunctionCall(func,args,args[args.length-1].sourceEnd);}
2765     throw new Error("Missing return statement in function");
2766   }
2767
2768 /**
2769  * An argument list is a list of arguments separated by comma :
2770  * argumentDeclaration() (, argumentDeclaration)*
2771  * @return an array of arguments
2772  */
2773   static final public Expression[] ArgumentList() throws ParseException {
2774 Expression arg;
2775 final ArrayList list = new ArrayList();
2776 int pos;
2777 Token token;
2778     arg = Expression();
2779    list.add(arg);pos = arg.sourceEnd;
2780     label_21:
2781     while (true) {
2782       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2783       case COMMA:
2784         ;
2785         break;
2786       default:
2787         jj_la1[75] = jj_gen;
2788         break label_21;
2789       }
2790       token = jj_consume_token(COMMA);
2791                      pos = token.sourceEnd;
2792       try {
2793         arg = Expression();
2794          list.add(arg);
2795          pos = arg.sourceEnd;
2796       } catch (ParseException e) {
2797         errorMessage = "unexpected token : '"+ e.currentToken.next.image +"'. An expression expected after a comma in argument list";
2798         errorLevel   = ERROR;
2799         errorStart   = pos+1;
2800         errorEnd     = pos+1;
2801         processParseException(e);
2802       }
2803     }
2804    final Expression[] arguments = new Expression[list.size()];
2805    list.toArray(arguments);
2806    {if (true) return arguments;}
2807     throw new Error("Missing return statement in function");
2808   }
2809
2810 /**
2811  * A Statement without break.
2812  * @return a statement
2813  */
2814   static final public Statement StatementNoBreak() throws ParseException {
2815   final Statement statement;
2816   Token token = null;
2817     if (jj_2_4(2)) {
2818       statement = expressionStatement();
2819                                          {if (true) return statement;}
2820     } else {
2821       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2822       case IDENTIFIER:
2823         statement = LabeledStatement();
2824                                          {if (true) return statement;}
2825         break;
2826       case LBRACE:
2827         statement = Block();
2828                                          {if (true) return statement;}
2829         break;
2830       case SEMICOLON:
2831         statement = EmptyStatement();
2832                                          {if (true) return statement;}
2833         break;
2834       case SWITCH:
2835         statement = SwitchStatement();
2836                                          {if (true) return statement;}
2837         break;
2838       case IF:
2839         statement = IfStatement();
2840                                          {if (true) return statement;}
2841         break;
2842       case WHILE:
2843         statement = WhileStatement();
2844                                          {if (true) return statement;}
2845         break;
2846       case DO:
2847         statement = DoStatement();
2848                                          {if (true) return statement;}
2849         break;
2850       case FOR:
2851         statement = ForStatement();
2852                                          {if (true) return statement;}
2853         break;
2854       case FOREACH:
2855         statement = ForeachStatement();
2856                                          {if (true) return statement;}
2857         break;
2858       case CONTINUE:
2859         statement = ContinueStatement();
2860                                          {if (true) return statement;}
2861         break;
2862       case RETURN:
2863         statement = ReturnStatement();
2864                                          {if (true) return statement;}
2865         break;
2866       case ECHO:
2867         statement = EchoStatement();
2868                                          {if (true) return statement;}
2869         break;
2870       case INCLUDE:
2871       case REQUIRE:
2872       case INCLUDE_ONCE:
2873       case REQUIRE_ONCE:
2874       case AT:
2875         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2876         case AT:
2877           token = jj_consume_token(AT);
2878           break;
2879         default:
2880           jj_la1[76] = jj_gen;
2881           ;
2882         }
2883         statement = IncludeStatement();
2884    if (token != null) {
2885     ((InclusionStatement)statement).silent = true;
2886     statement.sourceStart = token.sourceStart;
2887   }
2888   {if (true) return statement;}
2889         break;
2890       case STATIC:
2891         statement = StaticStatement();
2892                                          {if (true) return statement;}
2893         break;
2894       case GLOBAL:
2895         statement = GlobalStatement();
2896                                          {if (true) return statement;}
2897         break;
2898       case DEFINE:
2899         statement = defineStatement();
2900                                          currentSegment.add((Outlineable)statement);{if (true) return statement;}
2901         break;
2902       default:
2903         jj_la1[77] = jj_gen;
2904         jj_consume_token(-1);
2905         throw new ParseException();
2906       }
2907     }
2908     throw new Error("Missing return statement in function");
2909   }
2910
2911 /**
2912  * A statement expression.
2913  * expression ;
2914  * @return an expression
2915  */
2916   static final public Statement expressionStatement() throws ParseException {
2917   final Statement statement;
2918   final Token token;
2919     statement = Expression();
2920     try {
2921       token = jj_consume_token(SEMICOLON);
2922      statement.sourceEnd = token.sourceEnd;
2923     } catch (ParseException e) {
2924     if (e.currentToken.next.kind != PHPParserConstants.PHPEND) {
2925       errorMessage = "unexpected token : '"+ e.currentToken.next.image +"'. A ';' was expected";
2926       errorLevel   = ERROR;
2927       errorStart = statement.sourceEnd+1;
2928       errorEnd   = statement.sourceEnd+1;
2929       processParseExceptionDebug(e);
2930     }
2931     }
2932    {if (true) return statement;}
2933     throw new Error("Missing return statement in function");
2934   }
2935
2936   static final public Define defineStatement() throws ParseException {
2937   Expression defineName,defineValue;
2938   final Token defineToken;
2939   Token token;
2940   int pos;
2941     defineToken = jj_consume_token(DEFINE);
2942                           pos = defineToken.sourceEnd+1;
2943     try {
2944       token = jj_consume_token(LPAREN);
2945      pos = token.sourceEnd+1;
2946     } catch (ParseException e) {
2947     errorMessage = "unexpected token : '"+ e.currentToken.next.image +"', '(' expected";
2948     errorLevel   = ERROR;
2949     errorStart   = pos;
2950     errorEnd     = pos;
2951     processParseExceptionDebug(e);
2952     }
2953     try {
2954       defineName = Expression();
2955      pos = defineName.sourceEnd+1;
2956     } catch (ParseException e) {
2957     errorMessage = "unexpected token : '"+ e.currentToken.next.image +"', expression expected";
2958     errorLevel   = ERROR;
2959     errorStart   = pos;
2960     errorEnd     = pos;
2961     processParseExceptionDebug(e);
2962     defineName = new StringLiteral(SYNTAX_ERROR_CHAR,pos,pos);
2963     }
2964     try {
2965       token = jj_consume_token(COMMA);
2966      pos = defineName.sourceEnd+1;
2967     } catch (ParseException e) {
2968     errorMessage = "unexpected token : '"+ e.currentToken.next.image +"', ',' expected";
2969     errorLevel   = ERROR;
2970     errorStart   = pos;
2971     errorEnd     = pos;
2972     processParseExceptionDebug(e);
2973     }
2974     try {
2975       defineValue = Expression();
2976      pos = defineValue.sourceEnd+1;
2977     } catch (ParseException e) {
2978     errorMessage = "unexpected token : '"+ e.currentToken.next.image +"', expression expected";
2979     errorLevel   = ERROR;
2980     errorStart   = pos;
2981     errorEnd     = pos;
2982     processParseExceptionDebug(e);
2983     defineValue = new StringLiteral(SYNTAX_ERROR_CHAR,pos,pos);
2984     }
2985     try {
2986       token = jj_consume_token(RPAREN);
2987      pos = token.sourceEnd+1;
2988     } catch (ParseException e) {
2989     errorMessage = "unexpected token : '"+ e.currentToken.next.image +"', ')' expected";
2990     errorLevel   = ERROR;
2991     errorStart   = pos;
2992     errorEnd     = pos;
2993     processParseExceptionDebug(e);
2994     }
2995    {if (true) return new Define(currentSegment,
2996                      defineName,
2997                      defineValue,
2998                      defineToken.sourceStart,
2999                      pos);}
3000     throw new Error("Missing return statement in function");
3001   }
3002
3003 /**
3004  * A Normal statement.
3005  */
3006   static final public Statement Statement() throws ParseException {
3007   final Statement statement;
3008     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3009     case IF:
3010     case ARRAY:
3011     case LIST:
3012     case PRINT:
3013     case ECHO:
3014     case INCLUDE:
3015     case REQUIRE:
3016     case INCLUDE_ONCE:
3017     case REQUIRE_ONCE:
3018     case GLOBAL:
3019     case DEFINE:
3020     case STATIC:
3021     case CONTINUE:
3022     case DO:
3023     case FOR:
3024     case NEW:
3025     case NULL:
3026     case RETURN:
3027     case SWITCH:
3028     case TRUE:
3029     case FALSE:
3030     case WHILE:
3031     case FOREACH:
3032     case AT:
3033     case BANG:
3034     case TILDE:
3035     case PLUS_PLUS:
3036     case MINUS_MINUS:
3037     case PLUS:
3038     case MINUS:
3039     case BIT_AND:
3040     case INTEGER_LITERAL:
3041     case FLOATING_POINT_LITERAL:
3042     case STRING_LITERAL:
3043     case DOUBLEQUOTE:
3044     case DOLLAR:
3045     case IDENTIFIER:
3046     case LPAREN:
3047     case LBRACE:
3048     case SEMICOLON:
3049       statement = StatementNoBreak();
3050                                   {if (true) return statement;}
3051       break;
3052     case BREAK:
3053       statement = BreakStatement();
3054                                   {if (true) return statement;}
3055       break;
3056     default:
3057       jj_la1[78] = jj_gen;
3058       jj_consume_token(-1);
3059       throw new ParseException();
3060     }
3061     throw new Error("Missing return statement in function");
3062   }
3063
3064 /**
3065  * An html block inside a php syntax.
3066  */
3067   static final public HTMLBlock htmlBlock() throws ParseException {
3068   final int startIndex = nodePtr;
3069   final AstNode[] blockNodes;
3070   final int nbNodes;
3071   final Token phpEnd;
3072     phpEnd = jj_consume_token(PHPEND);
3073    htmlStart = phpEnd.sourceEnd;
3074     label_22:
3075     while (true) {
3076       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3077       case PHPECHOSTART:
3078         ;
3079         break;
3080       default:
3081         jj_la1[79] = jj_gen;
3082         break label_22;
3083       }
3084       phpEchoBlock();
3085     }
3086     try {
3087       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3088       case PHPSTARTLONG:
3089         jj_consume_token(PHPSTARTLONG);
3090         break;
3091       case PHPSTARTSHORT:
3092         jj_consume_token(PHPSTARTSHORT);
3093         break;
3094       default:
3095         jj_la1[80] = jj_gen;
3096         jj_consume_token(-1);
3097         throw new ParseException();
3098       }
3099      PHPParser.createNewHTMLCode();
3100     } catch (ParseException e) {
3101     errorMessage = "unexpected end of file , '<?php' expected";
3102     errorLevel   = ERROR;
3103     errorStart   = SimpleCharStream.getPosition();
3104     errorEnd     = SimpleCharStream.getPosition();
3105     {if (true) throw e;}
3106     }
3107   nbNodes    = nodePtr - startIndex;
3108   if (nbNodes == 0) {
3109     {if (true) return null;}
3110   }
3111   blockNodes = new AstNode[nbNodes];
3112   System.arraycopy(nodes,startIndex+1,blockNodes,0,nbNodes);
3113   nodePtr = startIndex;
3114   {if (true) return new HTMLBlock(blockNodes);}
3115     throw new Error("Missing return statement in function");
3116   }
3117
3118 /**
3119  * An include statement. It's "include" an expression;
3120  */
3121   static final public InclusionStatement IncludeStatement() throws ParseException {
3122   Expression expr;
3123   final int keyword;
3124   final InclusionStatement inclusionStatement;
3125   final Token token, token2;
3126   int pos;
3127     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3128     case REQUIRE:
3129       token = jj_consume_token(REQUIRE);
3130                                  keyword = InclusionStatement.REQUIRE;pos=token.sourceEnd;
3131       break;
3132     case REQUIRE_ONCE:
3133       token = jj_consume_token(REQUIRE_ONCE);
3134                                  keyword = InclusionStatement.REQUIRE_ONCE;pos=token.sourceEnd;
3135       break;
3136     case INCLUDE:
3137       token = jj_consume_token(INCLUDE);
3138                                  keyword = InclusionStatement.INCLUDE;pos=token.sourceEnd;
3139       break;
3140     case INCLUDE_ONCE:
3141       token = jj_consume_token(INCLUDE_ONCE);
3142                                  keyword = InclusionStatement.INCLUDE_ONCE;pos=token.sourceEnd;
3143       break;
3144     default:
3145       jj_la1[81] = jj_gen;
3146       jj_consume_token(-1);
3147       throw new ParseException();
3148     }
3149     try {
3150       expr = Expression();
3151      pos = expr.sourceEnd;
3152     } catch (ParseException e) {
3153     if (errorMessage != null) {
3154       {if (true) throw e;}
3155     }
3156     errorMessage = "unexpected token '"+ e.currentToken.next.image+"', expression expected";
3157     errorLevel   = ERROR;
3158     errorStart   = e.currentToken.next.sourceStart;
3159     errorEnd     = e.currentToken.next.sourceEnd;
3160     expr = new ConstantIdentifier(SYNTAX_ERROR_CHAR,pos,pos);
3161     processParseExceptionDebug(e);
3162     }
3163     try {
3164       token2 = jj_consume_token(SEMICOLON);
3165      pos=token2.sourceEnd;
3166     } catch (ParseException e) {
3167     errorMessage = "unexpected token : '"+ e.currentToken.next.image +"'. A ';' was expected";
3168     errorLevel   = ERROR;
3169     errorStart   = e.currentToken.next.sourceStart;
3170     errorEnd     = e.currentToken.next.sourceEnd;
3171     processParseExceptionDebug(e);
3172     }
3173    inclusionStatement = new InclusionStatement(currentSegment,
3174                                                keyword,
3175                                                expr,
3176                                                token.sourceStart,
3177                                                pos);
3178    currentSegment.add(inclusionStatement);
3179    {if (true) return inclusionStatement;}
3180     throw new Error("Missing return statement in function");
3181   }
3182
3183   static final public PrintExpression PrintExpression() throws ParseException {
3184   final Expression expr;
3185   final Token printToken;
3186     token = jj_consume_token(PRINT);
3187     expr = Expression();
3188    {if (true) return new PrintExpression(expr,token.sourceStart,expr.sourceEnd);}
3189     throw new Error("Missing return statement in function");
3190   }
3191
3192   static final public ListExpression ListExpression() throws ParseException {
3193   Expression expr = null;
3194   final Expression expression;
3195   final ArrayList list = new ArrayList();
3196   int pos;
3197   final Token listToken, rParen;
3198   Token token;
3199     listToken = jj_consume_token(LIST);
3200                       pos = listToken.sourceEnd;
3201     try {
3202       token = jj_consume_token(LPAREN);
3203                       pos = token.sourceEnd;
3204     } catch (ParseException e) {
3205     errorMessage = "unexpected token : '"+ e.currentToken.next.image +"', '(' expected";
3206     errorLevel   = ERROR;
3207     errorStart   = listToken.sourceEnd+1;
3208     errorEnd     = listToken.sourceEnd+1;
3209     processParseExceptionDebug(e);
3210     }
3211     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3212     case DOLLAR:
3213       expr = VariableDeclaratorId();
3214      list.add(expr);pos = expr.sourceEnd;
3215       break;
3216     default:
3217       jj_la1[82] = jj_gen;
3218       ;
3219     }
3220    if (expr == null) list.add(null);
3221     label_23:
3222     while (true) {
3223       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3224       case COMMA:
3225         ;
3226         break;
3227       default:
3228         jj_la1[83] = jj_gen;
3229         break label_23;
3230       }
3231       try {
3232         token = jj_consume_token(COMMA);
3233        pos = token.sourceEnd;
3234       } catch (ParseException e) {
3235       errorMessage = "unexpected token : '"+ e.currentToken.next.image +"', ',' expected";
3236       errorLevel   = ERROR;
3237       errorStart   = pos+1;
3238       errorEnd     = pos+1;
3239       processParseExceptionDebug(e);
3240       }
3241       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3242       case DOLLAR:
3243         expr = VariableDeclaratorId();
3244                                     list.add(expr);pos = expr.sourceEnd;
3245         break;
3246       default:
3247         jj_la1[84] = jj_gen;
3248         ;
3249       }
3250     }
3251     try {
3252       rParen = jj_consume_token(RPAREN);
3253      pos = rParen.sourceEnd;
3254     } catch (ParseException e) {
3255     errorMessage = "unexpected token : '"+ e.currentToken.next.image +"', ')' expected";
3256     errorLevel   = ERROR;
3257     errorStart = pos+1;
3258     errorEnd   = pos+1;
3259       processParseExceptionDebug(e);
3260     }
3261     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3262     case ASSIGN:
3263       jj_consume_token(ASSIGN);
3264       expression = Expression();
3265     final AbstractVariable[] vars = new AbstractVariable[list.size()];
3266     list.toArray(vars);
3267     {if (true) return new ListExpression(vars,
3268                               expression,
3269                               listToken.sourceStart,
3270                               expression.sourceEnd);}
3271       break;
3272     default:
3273       jj_la1[85] = jj_gen;
3274       ;
3275     }
3276     final AbstractVariable[] vars = new AbstractVariable[list.size()];
3277     list.toArray(vars);
3278     {if (true) return new ListExpression(vars,listToken.sourceStart,pos);}
3279     throw new Error("Missing return statement in function");
3280   }
3281
3282 /**
3283  * An echo statement.
3284  * echo anyexpression (, otherexpression)*
3285  */
3286   static final public EchoStatement EchoStatement() throws ParseException {
3287   final ArrayList expressions = new ArrayList();
3288   Expression expr;
3289   Token token;
3290   Token token2 = null;
3291     token = jj_consume_token(ECHO);
3292     expr = Expression();
3293    expressions.add(expr);
3294     label_24:
3295     while (true) {
3296       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3297       case COMMA:
3298         ;
3299         break;
3300       default:
3301         jj_la1[86] = jj_gen;
3302         break label_24;
3303       }
3304       jj_consume_token(COMMA);
3305       expr = Expression();
3306      expressions.add(expr);
3307     }
3308     try {
3309       token2 = jj_consume_token(SEMICOLON);
3310     } catch (ParseException e) {
3311     if (e.currentToken.next.kind != 4) {
3312       errorMessage = "';' expected after 'echo' statement";
3313       errorLevel   = ERROR;
3314       errorStart   = e.currentToken.sourceEnd;
3315       errorEnd     = e.currentToken.sourceEnd;
3316       processParseExceptionDebug(e);
3317     }
3318     }
3319    final Expression[] exprs = new Expression[expressions.size()];
3320    expressions.toArray(exprs);
3321    if (token2 == null) {
3322      {if (true) return new EchoStatement(exprs,token.sourceStart, exprs[exprs.length-1].sourceEnd);}
3323    }
3324    {if (true) return new EchoStatement(exprs,token.sourceStart, token2.sourceEnd);}
3325     throw new Error("Missing return statement in function");
3326   }
3327
3328   static final public GlobalStatement GlobalStatement() throws ParseException {
3329    Variable expr;
3330    final ArrayList vars = new ArrayList();
3331    final GlobalStatement global;
3332    final Token token, token2;
3333    int pos;
3334     token = jj_consume_token(GLOBAL);
3335     expr = Variable();
3336      vars.add(expr);pos = expr.sourceEnd+1;
3337     label_25:
3338     while (true) {
3339       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3340       case COMMA:
3341         ;
3342         break;
3343       default:
3344         jj_la1[87] = jj_gen;
3345         break label_25;
3346       }
3347       jj_consume_token(COMMA);
3348       expr = Variable();
3349      vars.add(expr);pos = expr.sourceEnd+1;
3350     }
3351     try {
3352       token2 = jj_consume_token(SEMICOLON);
3353      pos = token2.sourceEnd+1;
3354     } catch (ParseException e) {
3355     errorMessage = "unexpected token : '"+ e.currentToken.next.image +"'. a ';' was expected";
3356     errorLevel   = ERROR;
3357     errorStart = pos;
3358     errorEnd   = pos;
3359     processParseExceptionDebug(e);
3360     }
3361     final Variable[] variables = new Variable[vars.size()];
3362     vars.toArray(variables);
3363     global = new GlobalStatement(currentSegment,
3364                                  variables,
3365                                  token.sourceStart,
3366                                  pos);
3367     currentSegment.add(global);
3368     {if (true) return global;}
3369     throw new Error("Missing return statement in function");
3370   }
3371
3372   static final public StaticStatement StaticStatement() throws ParseException {
3373   final ArrayList vars = new ArrayList();
3374   VariableDeclaration expr;
3375   final Token token, token2;
3376   int pos;
3377     token = jj_consume_token(STATIC);
3378     expr = VariableDeclarator();
3379                                                 vars.add(expr);pos = expr.sourceEnd+1;
3380     label_26:
3381     while (true) {
3382       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3383       case COMMA:
3384         ;
3385         break;
3386       default:
3387         jj_la1[88] = jj_gen;
3388         break label_26;
3389       }
3390       jj_consume_token(COMMA);
3391       expr = VariableDeclarator();
3392                                          vars.add(expr);pos = expr.sourceEnd+1;
3393     }
3394     try {
3395       token2 = jj_consume_token(SEMICOLON);
3396      pos = token2.sourceEnd+1;
3397     } catch (ParseException e) {
3398     errorMessage = "unexpected token : '"+ e.currentToken.next.image +"'. a ';' was expected";
3399     errorLevel   = ERROR;
3400     errorStart = pos;
3401     errorEnd   = pos;
3402     processParseException(e);
3403     }
3404     final VariableDeclaration[] variables = new VariableDeclaration[vars.size()];
3405     vars.toArray(variables);
3406     {if (true) return new StaticStatement(variables,
3407                                token.sourceStart,
3408                                pos);}
3409     throw new Error("Missing return statement in function");
3410   }
3411
3412   static final public LabeledStatement LabeledStatement() throws ParseException {
3413   final Token label;
3414   final Statement statement;
3415     label = jj_consume_token(IDENTIFIER);
3416     jj_consume_token(COLON);
3417     statement = Statement();
3418    {if (true) return new LabeledStatement(label.image,statement,label.sourceStart,statement.sourceEnd);}
3419     throw new Error("Missing return statement in function");
3420   }
3421
3422 /**
3423  * A Block is
3424  * {
3425  * statements
3426  * }.
3427  * @return a block
3428  */
3429   static final public Block Block() throws ParseException {
3430   final ArrayList list = new ArrayList();
3431   Statement statement;
3432   final Token token, token2;
3433   int pos,start;
3434     try {
3435       token = jj_consume_token(LBRACE);
3436      pos = token.sourceEnd+1;start=token.sourceStart;
3437     } catch (ParseException e) {
3438     errorMessage = "'{' expected";
3439     errorLevel   = ERROR;
3440     pos = PHPParser.token.sourceEnd+1;
3441     start=pos;
3442     errorStart = pos;
3443     errorEnd   = pos;
3444     processParseExceptionDebug(e);
3445     }
3446     label_27:
3447     while (true) {
3448       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3449       case PHPEND:
3450       case CLASS:
3451       case FUNCTION:
3452       case IF:
3453       case ARRAY:
3454       case BREAK:
3455       case LIST:
3456       case PRINT:
3457       case ECHO:
3458       case INCLUDE:
3459       case REQUIRE:
3460       case INCLUDE_ONCE:
3461       case REQUIRE_ONCE:
3462       case GLOBAL:
3463       case DEFINE:
3464       case STATIC:
3465       case CONTINUE:
3466       case DO:
3467       case FOR:
3468       case NEW:
3469       case NULL:
3470       case RETURN:
3471       case SWITCH:
3472       case TRUE:
3473       case FALSE:
3474       case WHILE:
3475       case FOREACH:
3476       case AT:
3477       case BANG:
3478       case TILDE:
3479       case PLUS_PLUS:
3480       case MINUS_MINUS:
3481       case PLUS:
3482       case MINUS:
3483       case BIT_AND:
3484       case INTEGER_LITERAL:
3485       case FLOATING_POINT_LITERAL:
3486       case STRING_LITERAL:
3487       case DOUBLEQUOTE:
3488       case DOLLAR:
3489       case IDENTIFIER:
3490       case LPAREN:
3491       case LBRACE:
3492       case SEMICOLON:
3493         ;
3494         break;
3495       default:
3496         jj_la1[89] = jj_gen;
3497         break label_27;
3498       }
3499       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3500       case CLASS:
3501       case FUNCTION:
3502       case IF:
3503       case ARRAY:
3504       case BREAK:
3505       case LIST:
3506       case PRINT:
3507       case ECHO:
3508       case INCLUDE:
3509       case REQUIRE:
3510       case INCLUDE_ONCE:
3511       case REQUIRE_ONCE:
3512       case GLOBAL:
3513       case DEFINE:
3514       case STATIC:
3515       case CONTINUE:
3516       case DO:
3517       case FOR:
3518       case NEW:
3519       case NULL:
3520       case RETURN:
3521       case SWITCH:
3522       case TRUE:
3523       case FALSE:
3524       case WHILE:
3525       case FOREACH:
3526       case AT:
3527       case BANG:
3528       case TILDE:
3529       case PLUS_PLUS:
3530       case MINUS_MINUS:
3531       case PLUS:
3532       case MINUS:
3533       case BIT_AND:
3534       case INTEGER_LITERAL:
3535       case FLOATING_POINT_LITERAL:
3536       case STRING_LITERAL:
3537       case DOUBLEQUOTE:
3538       case DOLLAR:
3539       case IDENTIFIER:
3540       case LPAREN:
3541       case LBRACE:
3542       case SEMICOLON:
3543         statement = BlockStatement();
3544                                   list.add(statement);pos = statement.sourceEnd+1;
3545         break;
3546       case PHPEND:
3547         statement = htmlBlock();
3548                                   if (statement != null) {
3549                                     list.add(statement);
3550                                     pos = statement.sourceEnd+1;
3551                                   }
3552                                   pos = PHPParser.token.sourceEnd+1;
3553         break;
3554       default:
3555         jj_la1[90] = jj_gen;
3556         jj_consume_token(-1);
3557         throw new ParseException();
3558       }
3559     }
3560     try {
3561       token2 = jj_consume_token(RBRACE);
3562      pos = token2.sourceEnd+1;
3563     } catch (ParseException e) {
3564     errorMessage = "unexpected token : '"+ e.currentToken.image +"', '}' expected";
3565     errorLevel   = ERROR;
3566     errorStart = pos;
3567     errorEnd   = pos;
3568     processParseExceptionDebug(e);
3569     }
3570   final Statement[] statements = new Statement[list.size()];
3571   list.toArray(statements);
3572   {if (true) return new Block(statements,start,pos);}
3573     throw new Error("Missing return statement in function");
3574   }
3575
3576   static final public Statement BlockStatement() throws ParseException {
3577   final Statement statement;
3578     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3579     case IF:
3580     case ARRAY:
3581     case BREAK:
3582     case LIST:
3583     case PRINT:
3584     case ECHO:
3585     case INCLUDE:
3586     case REQUIRE:
3587     case INCLUDE_ONCE:
3588     case REQUIRE_ONCE:
3589     case GLOBAL:
3590     case DEFINE:
3591     case STATIC:
3592     case CONTINUE:
3593     case DO:
3594     case FOR:
3595     case NEW:
3596     case NULL:
3597     case RETURN:
3598     case SWITCH:
3599     case TRUE:
3600     case FALSE:
3601     case WHILE:
3602     case FOREACH:
3603     case AT:
3604     case BANG:
3605     case TILDE:
3606     case PLUS_PLUS:
3607     case MINUS_MINUS:
3608     case PLUS:
3609     case MINUS:
3610     case BIT_AND:
3611     case INTEGER_LITERAL:
3612     case FLOATING_POINT_LITERAL:
3613     case STRING_LITERAL:
3614     case DOUBLEQUOTE:
3615     case DOLLAR:
3616     case IDENTIFIER:
3617     case LPAREN:
3618     case LBRACE:
3619     case SEMICOLON:
3620       try {
3621         statement = Statement();
3622                                      if (phpDocument == currentSegment) pushOnAstNodes(statement);
3623                                      {if (true) return statement;}
3624       } catch (ParseException e) {
3625     errorMessage = "unexpected token : '"+ e.currentToken.image +"', a statement was expected";
3626     errorLevel   = ERROR;
3627     errorStart = e.currentToken.sourceStart;
3628     errorEnd   = e.currentToken.sourceEnd;
3629     {if (true) throw e;}
3630       }
3631       break;
3632     case CLASS:
3633       statement = ClassDeclaration();
3634                                    {if (true) return statement;}
3635       break;
3636     case FUNCTION:
3637       statement = MethodDeclaration();
3638                                    if (phpDocument == currentSegment) pushOnAstNodes(statement);
3639                                    currentSegment.add((MethodDeclaration) statement);
3640                                    ((MethodDeclaration) statement).analyzeCode();
3641                                    {if (true) return statement;}
3642       break;
3643     default:
3644       jj_la1[91] = jj_gen;
3645       jj_consume_token(-1);
3646       throw new ParseException();
3647     }
3648     throw new Error("Missing return statement in function");
3649   }
3650
3651 /**
3652  * A Block statement that will not contain any 'break'
3653  */
3654   static final public Statement BlockStatementNoBreak() throws ParseException {
3655   final Statement statement;
3656     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3657     case IF:
3658     case ARRAY:
3659     case LIST:
3660     case PRINT:
3661     case ECHO:
3662     case INCLUDE:
3663     case REQUIRE:
3664     case INCLUDE_ONCE:
3665     case REQUIRE_ONCE:
3666     case GLOBAL:
3667     case DEFINE:
3668     case STATIC:
3669     case CONTINUE:
3670     case DO:
3671     case FOR:
3672     case NEW:
3673     case NULL:
3674     case RETURN:
3675     case SWITCH:
3676     case TRUE:
3677     case FALSE:
3678     case WHILE:
3679     case FOREACH:
3680     case AT:
3681     case BANG:
3682     case TILDE:
3683     case PLUS_PLUS:
3684     case MINUS_MINUS:
3685     case PLUS:
3686     case MINUS:
3687     case BIT_AND:
3688     case INTEGER_LITERAL:
3689     case FLOATING_POINT_LITERAL:
3690     case STRING_LITERAL:
3691     case DOUBLEQUOTE:
3692     case DOLLAR:
3693     case IDENTIFIER:
3694     case LPAREN:
3695     case LBRACE:
3696     case SEMICOLON:
3697       statement = StatementNoBreak();
3698                                    {if (true) return statement;}
3699       break;
3700     case CLASS:
3701       statement = ClassDeclaration();
3702                                    {if (true) return statement;}
3703       break;
3704     case FUNCTION:
3705       statement = MethodDeclaration();
3706                                    currentSegment.add((MethodDeclaration) statement);
3707                                    ((MethodDeclaration) statement).analyzeCode();
3708                                    {if (true) return statement;}
3709       break;
3710     default:
3711       jj_la1[92] = jj_gen;
3712       jj_consume_token(-1);
3713       throw new ParseException();
3714     }
3715     throw new Error("Missing return statement in function");
3716   }
3717
3718 /**
3719  * used only by ForInit()
3720  */
3721   static final public Expression[] LocalVariableDeclaration() throws ParseException {
3722   final ArrayList list = new ArrayList();
3723   Expression var;
3724     var = Expression();
3725    list.add(var);
3726     label_28:
3727     while (true) {
3728       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3729       case COMMA:
3730         ;
3731         break;
3732       default:
3733         jj_la1[93] = jj_gen;
3734         break label_28;
3735       }
3736       jj_consume_token(COMMA);
3737       var = Expression();
3738                                 list.add(var);
3739     }
3740     final Expression[] vars = new Expression[list.size()];
3741     list.toArray(vars);
3742     {if (true) return vars;}
3743     throw new Error("Missing return statement in function");
3744   }
3745
3746 /**
3747  * used only by LocalVariableDeclaration().
3748  */
3749   static final public VariableDeclaration LocalVariableDeclarator() throws ParseException {
3750   final Variable varName;
3751   Expression initializer = null;
3752     varName = Variable();
3753     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3754     case ASSIGN:
3755       jj_consume_token(ASSIGN);
3756       initializer = Expression();
3757       break;
3758     default:
3759       jj_la1[94] = jj_gen;
3760       ;
3761     }
3762    if (initializer == null) {
3763     {if (true) return new VariableDeclaration(currentSegment,
3764                                    varName,
3765                                    varName.sourceStart,
3766                                    varName.sourceEnd);}
3767    }
3768     {if (true) return new VariableDeclaration(currentSegment,
3769                                    varName,
3770                                    initializer,
3771                                    VariableDeclaration.EQUAL,
3772                                    varName.sourceStart);}
3773     throw new Error("Missing return statement in function");
3774   }
3775
3776   static final public EmptyStatement EmptyStatement() throws ParseException {
3777   final Token token;
3778     token = jj_consume_token(SEMICOLON);
3779    {if (true) return new EmptyStatement(token.sourceStart,token.sourceEnd);}
3780     throw new Error("Missing return statement in function");
3781   }
3782
3783 /**
3784  * used only by StatementExpressionList() which is used only by ForInit() and ForStatement()
3785  */
3786   static final public Expression StatementExpression() throws ParseException {
3787   final Expression expr;
3788   final Token operator;
3789     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3790     case PLUS_PLUS:
3791     case MINUS_MINUS:
3792       expr = PreIncDecExpression();
3793                                 {if (true) return expr;}
3794       break;
3795     case ARRAY:
3796     case NEW:
3797     case BIT_AND:
3798     case DOLLAR:
3799     case IDENTIFIER:
3800       expr = PrimaryExpression();
3801       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3802       case PLUS_PLUS:
3803       case MINUS_MINUS:
3804         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3805         case PLUS_PLUS:
3806           operator = jj_consume_token(PLUS_PLUS);
3807                             {if (true) return new PostfixedUnaryExpression(expr,
3808                                                                 OperatorIds.PLUS_PLUS,
3809                                                                 operator.sourceEnd);}
3810           break;
3811         case MINUS_MINUS:
3812           operator = jj_consume_token(MINUS_MINUS);
3813                               {if (true) return new PostfixedUnaryExpression(expr,
3814                                                                   OperatorIds.MINUS_MINUS,
3815                                                                   operator.sourceEnd);}
3816           break;
3817         default:
3818           jj_la1[95] = jj_gen;
3819           jj_consume_token(-1);
3820           throw new ParseException();
3821         }
3822         break;
3823       default:
3824         jj_la1[96] = jj_gen;
3825         ;
3826       }
3827    {if (true) return expr;}
3828       break;
3829     default:
3830       jj_la1[97] = jj_gen;
3831       jj_consume_token(-1);
3832       throw new ParseException();
3833     }
3834     throw new Error("Missing return statement in function");
3835   }
3836
3837   static final public SwitchStatement SwitchStatement() throws ParseException {
3838   Expression variable;
3839   final AbstractCase[] cases;
3840   final Token switchToken,lparenToken,rparenToken;
3841   int pos;
3842     switchToken = jj_consume_token(SWITCH);
3843                           pos = switchToken.sourceEnd+1;
3844     try {
3845       lparenToken = jj_consume_token(LPAREN);
3846      pos = lparenToken.sourceEnd+1;
3847     } catch (ParseException e) {
3848     errorMessage = "'(' expected after 'switch'";
3849     errorLevel   = ERROR;
3850     errorStart = pos;
3851     errorEnd   = pos;
3852     processParseExceptionDebug(e);
3853     }
3854     try {
3855       variable = Expression();
3856                              pos = variable.sourceEnd+1;
3857     } catch (ParseException e) {
3858     if (errorMessage != null) {
3859       {if (true) throw e;}
3860     }
3861     errorMessage = "expression expected";
3862     errorLevel   = ERROR;
3863     errorStart = pos;
3864     errorEnd   = pos;
3865     processParseExceptionDebug(e);
3866     variable = new ConstantIdentifier(SYNTAX_ERROR_CHAR,pos,pos);
3867     }
3868     try {
3869       rparenToken = jj_consume_token(RPAREN);
3870                             pos = rparenToken.sourceEnd+1;
3871     } catch (ParseException e) {
3872     errorMessage = "')' expected";
3873     errorLevel   = ERROR;
3874     errorStart = pos;
3875     errorEnd   = pos;
3876     processParseExceptionDebug(e);
3877     }
3878     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3879     case LBRACE:
3880       cases = switchStatementBrace();
3881       break;
3882     case COLON:
3883       cases = switchStatementColon(switchToken.sourceStart, switchToken.sourceEnd);
3884       break;
3885     default:
3886       jj_la1[98] = jj_gen;
3887       jj_consume_token(-1);
3888       throw new ParseException();
3889     }
3890    {if (true) return new SwitchStatement(variable,
3891                               cases,
3892                               switchToken.sourceStart,
3893                               PHPParser.token.sourceEnd);}
3894     throw new Error("Missing return statement in function");
3895   }
3896
3897   static final public AbstractCase[] switchStatementBrace() throws ParseException {
3898   AbstractCase cas;
3899   final ArrayList cases = new ArrayList();
3900   Token token;
3901   int pos;
3902     token = jj_consume_token(LBRACE);
3903                     pos = token.sourceEnd;
3904     label_29:
3905     while (true) {
3906       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3907       case CASE:
3908       case _DEFAULT:
3909         ;
3910         break;
3911       default:
3912         jj_la1[99] = jj_gen;
3913         break label_29;
3914       }
3915       cas = switchLabel0();
3916                          cases.add(cas);pos = cas.sourceEnd;
3917     }
3918     try {
3919       token = jj_consume_token(RBRACE);
3920      pos = token.sourceEnd;
3921     } catch (ParseException e) {
3922     errorMessage = "'}' expected";
3923     errorLevel   = ERROR;
3924     errorStart = pos+1;
3925     errorEnd   = pos+1;
3926     processParseExceptionDebug(e);
3927     }
3928     final AbstractCase[] abcase = new AbstractCase[cases.size()];
3929     cases.toArray(abcase);
3930     {if (true) return abcase;}
3931     throw new Error("Missing return statement in function");
3932   }
3933
3934 /**
3935  * A Switch statement with : ... endswitch;
3936  * @param start the begin offset of the switch
3937  * @param end the end offset of the switch
3938  */
3939   static final public AbstractCase[] switchStatementColon(final int start, final int end) throws ParseException {
3940   AbstractCase cas;
3941   final ArrayList cases = new ArrayList();
3942   Token token;
3943   int pos;
3944     token = jj_consume_token(COLON);
3945                    pos = token.sourceEnd;
3946    try {
3947   setMarker(fileToParse,
3948             "Ugly syntax detected, you should switch () {...} instead of switch (): ... enswitch;",
3949             start,
3950             end,
3951             INFO,
3952             "Line " + token.beginLine);
3953   } catch (CoreException e) {
3954     PHPeclipsePlugin.log(e);
3955   }
3956     label_30:
3957     while (true) {
3958       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3959       case CASE:
3960       case _DEFAULT:
3961         ;
3962         break;
3963       default:
3964         jj_la1[100] = jj_gen;
3965         break label_30;
3966       }
3967       cas = switchLabel0();
3968                           cases.add(cas);pos = cas.sourceEnd;
3969     }
3970     try {
3971       token = jj_consume_token(ENDSWITCH);
3972                          pos = token.sourceEnd;
3973     } catch (ParseException e) {
3974     errorMessage = "'endswitch' expected";
3975     errorLevel   = ERROR;
3976     errorStart = pos+1;
3977     errorEnd   = pos+1;
3978     processParseExceptionDebug(e);
3979     }
3980     try {
3981       token = jj_consume_token(SEMICOLON);
3982                          pos = token.sourceEnd;
3983     } catch (ParseException e) {
3984     errorMessage = "';' expected after 'endswitch' keyword";
3985     errorLevel   = ERROR;
3986     errorStart = pos+1;
3987     errorEnd   = pos+1;
3988     processParseExceptionDebug(e);
3989     }
3990     final AbstractCase[] abcase = new AbstractCase[cases.size()];
3991     cases.toArray(abcase);
3992     {if (true) return abcase;}
3993     throw new Error("Missing return statement in function");
3994   }
3995
3996   static final public AbstractCase switchLabel0() throws ParseException {
3997   final Expression expr;
3998   Statement statement;
3999   final ArrayList stmts = new ArrayList();
4000   final Token token = PHPParser.token;
4001     expr = SwitchLabel();
4002     label_31:
4003     while (true) {
4004       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
4005       case PHPEND:
4006       case CLASS:
4007       case FUNCTION:
4008       case IF:
4009       case ARRAY:
4010       case BREAK:
4011       case LIST:
4012       case PRINT:
4013       case ECHO:
4014       case INCLUDE:
4015       case REQUIRE:
4016       case INCLUDE_ONCE:
4017       case REQUIRE_ONCE:
4018       case GLOBAL:
4019       case DEFINE:
4020       case STATIC:
4021       case CONTINUE:
4022       case DO:
4023       case FOR:
4024       case NEW:
4025       case NULL:
4026       case RETURN:
4027       case SWITCH:
4028       case TRUE:
4029       case FALSE:
4030       case WHILE:
4031       case FOREACH:
4032       case AT:
4033       case BANG:
4034       case TILDE:
4035       case PLUS_PLUS:
4036       case MINUS_MINUS:
4037       case PLUS:
4038       case MINUS:
4039       case BIT_AND:
4040       case INTEGER_LITERAL:
4041       case FLOATING_POINT_LITERAL:
4042       case STRING_LITERAL:
4043       case DOUBLEQUOTE:
4044       case DOLLAR:
4045       case IDENTIFIER:
4046       case LPAREN:
4047       case LBRACE:
4048       case SEMICOLON:
4049         ;
4050         break;
4051       default:
4052         jj_la1[101] = jj_gen;
4053         break label_31;
4054       }
4055       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
4056       case CLASS:
4057       case FUNCTION:
4058       case IF:
4059       case ARRAY:
4060       case LIST:
4061       case PRINT:
4062       case ECHO:
4063       case INCLUDE:
4064       case REQUIRE:
4065       case INCLUDE_ONCE:
4066       case REQUIRE_ONCE:
4067       case GLOBAL:
4068       case DEFINE:
4069       case STATIC:
4070       case CONTINUE:
4071       case DO:
4072       case FOR:
4073       case NEW:
4074       case NULL:
4075       case RETURN:
4076       case SWITCH:
4077       case TRUE:
4078       case FALSE:
4079       case WHILE:
4080       case FOREACH:
4081       case AT:
4082       case BANG:
4083       case TILDE:
4084       case PLUS_PLUS:
4085       case MINUS_MINUS:
4086       case PLUS:
4087       case MINUS:
4088       case BIT_AND:
4089       case INTEGER_LITERAL:
4090       case FLOATING_POINT_LITERAL:
4091       case STRING_LITERAL:
4092       case DOUBLEQUOTE:
4093       case DOLLAR:
4094       case IDENTIFIER:
4095       case LPAREN:
4096       case LBRACE:
4097       case SEMICOLON:
4098         statement = BlockStatementNoBreak();
4099                                          stmts.add(statement);
4100         break;
4101       case PHPEND:
4102         statement = htmlBlock();
4103                                          if (statement != null) {stmts.add(statement);}
4104         break;
4105       case BREAK:
4106         statement = BreakStatement();
4107                                          stmts.add(statement);
4108         break;
4109       default:
4110         jj_la1[102] = jj_gen;
4111         jj_consume_token(-1);
4112         throw new ParseException();
4113       }
4114     }
4115     final int listSize = stmts.size();
4116     final Statement[] stmtsArray = new Statement[listSize];
4117     stmts.toArray(stmtsArray);
4118     if (expr == null) {//it's a default
4119       {if (true) return new DefaultCase(stmtsArray,token.sourceStart,stmtsArray[listSize-1].sourceEnd);}
4120     }
4121     if (listSize != 0) {
4122       {if (true) return new Case(expr,stmtsArray,expr.sourceStart,stmtsArray[listSize-1].sourceEnd);}
4123     } else {
4124       {if (true) return new Case(expr,stmtsArray,expr.sourceStart,expr.sourceEnd);}
4125     }
4126     throw new Error("Missing return statement in function");
4127   }
4128
4129 /**
4130  * A SwitchLabel.
4131  * case Expression() :
4132  * default :
4133  * @return the if it was a case and null if not
4134  */
4135   static final public Expression SwitchLabel() throws ParseException {
4136   final Expression expr;
4137     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
4138     case CASE:
4139       token = jj_consume_token(CASE);
4140       try {
4141         expr = Expression();
4142       } catch (ParseException e) {
4143     if (errorMessage != null) {if (true) throw e;}
4144     errorMessage = "expression expected after 'case' keyword";
4145     errorLevel   = ERROR;
4146     errorStart = token.sourceEnd +1;
4147     errorEnd   = token.sourceEnd +1;
4148     {if (true) throw e;}
4149       }
4150       try {
4151         token = jj_consume_token(COLON);
4152      {if (true) return expr;}
4153       } catch (ParseException e) {
4154     errorMessage = "':' expected after case expression";
4155     errorLevel   = ERROR;
4156     errorStart = expr.sourceEnd+1;
4157     errorEnd   = expr.sourceEnd+1;
4158     processParseExceptionDebug(e);
4159       }
4160       break;
4161     case _DEFAULT:
4162       token = jj_consume_token(_DEFAULT);
4163       try {
4164         jj_consume_token(COLON);
4165      {if (true) return null;}
4166       } catch (ParseException e) {
4167     errorMessage = "':' expected after 'default' keyword";
4168     errorLevel   = ERROR;
4169     errorStart = token.sourceEnd+1;
4170     errorEnd   = token.sourceEnd+1;
4171     processParseExceptionDebug(e);
4172       }
4173       break;
4174     default:
4175       jj_la1[103] = jj_gen;
4176       jj_consume_token(-1);
4177       throw new ParseException();
4178     }
4179     throw new Error("Missing return statement in function");
4180   }
4181
4182   static final public Break BreakStatement() throws ParseException {
4183   Expression expression = null;
4184   final Token token, token2;
4185   int pos;
4186     token = jj_consume_token(BREAK);
4187                    pos = token.sourceEnd+1;
4188     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
4189     case ARRAY:
4190     case LIST:
4191     case PRINT:
4192     case NEW:
4193     case NULL:
4194     case TRUE:
4195     case FALSE:
4196     case AT:
4197     case BANG:
4198     case TILDE:
4199     case PLUS_PLUS:
4200     case MINUS_MINUS:
4201     case PLUS:
4202     case MINUS:
4203     case BIT_AND:
4204     case INTEGER_LITERAL:
4205     case FLOATING_POINT_LITERAL:
4206     case STRING_LITERAL:
4207     case DOUBLEQUOTE:
4208     case DOLLAR:
4209     case IDENTIFIER:
4210     case LPAREN:
4211       expression = Expression();
4212                                pos = expression.sourceEnd+1;
4213       break;
4214     default:
4215       jj_la1[104] = jj_gen;
4216       ;
4217     }
4218     try {
4219       token2 = jj_consume_token(SEMICOLON);
4220      pos = token2.sourceEnd;
4221     } catch (ParseException e) {
4222     errorMessage = "';' expected after 'break' keyword";
4223     errorLevel   = ERROR;
4224     errorStart = pos;
4225     errorEnd   = pos;
4226     processParseExceptionDebug(e);
4227     }
4228    {if (true) return new Break(expression, token.sourceStart, pos);}
4229     throw new Error("Missing return statement in function");
4230   }
4231
4232   static final public IfStatement IfStatement() throws ParseException {
4233   final Expression condition;
4234   final IfStatement ifStatement;
4235   Token token;
4236     token = jj_consume_token(IF);
4237     condition = Condition("if");
4238     ifStatement = IfStatement0(condition,token.sourceStart,token.sourceEnd);
4239    {if (true) return ifStatement;}
4240     throw new Error("Missing return statement in function");
4241   }
4242
4243   static final public Expression Condition(final String keyword) throws ParseException {
4244   final Expression condition;
4245     try {
4246       jj_consume_token(LPAREN);
4247     } catch (ParseException e) {
4248     errorMessage = "'(' expected after " + keyword + " keyword";
4249     errorLevel   = ERROR;
4250     errorStart = PHPParser.token.sourceEnd + 1;
4251     errorEnd   = PHPParser.token.sourceEnd + 1;
4252     processParseExceptionDebug(e);
4253     }
4254     condition = Expression();
4255     try {
4256       jj_consume_token(RPAREN);
4257     } catch (ParseException e) {
4258     errorMessage = "')' expected after " + keyword + " keyword";
4259     errorLevel   = ERROR;
4260     errorStart = condition.sourceEnd+1;
4261     errorEnd   = condition.sourceEnd+1;
4262     processParseExceptionDebug(e);
4263     }
4264    {if (true) return condition;}
4265     throw new Error("Missing return statement in function");
4266   }
4267
4268   static final public IfStatement IfStatement0(final Expression condition, final int start,final int end) throws ParseException {
4269   Statement statement;
4270   final Statement stmt;
4271   final Statement[] statementsArray;
4272   ElseIf elseifStatement;
4273   Else elseStatement = null;
4274   final ArrayList stmts;
4275   final ArrayList elseIfList = new ArrayList();
4276   final ElseIf[] elseIfs;
4277   int pos = SimpleCharStream.getPosition();
4278   final int endStatements;
4279     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
4280     case COLON:
4281       jj_consume_token(COLON);
4282    stmts = new ArrayList();
4283       label_32:
4284       while (true) {
4285         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
4286         case PHPEND:
4287         case IF:
4288         case ARRAY:
4289         case BREAK:
4290         case LIST:
4291         case PRINT:
4292         case ECHO:
4293         case INCLUDE:
4294         case REQUIRE:
4295         case INCLUDE_ONCE:
4296         case REQUIRE_ONCE:
4297         case GLOBAL:
4298         case DEFINE:
4299         case STATIC:
4300         case CONTINUE:
4301         case DO:
4302         case FOR:
4303         case NEW:
4304         case NULL:
4305         case RETURN:
4306         case SWITCH:
4307         case TRUE:
4308         case FALSE:
4309         case WHILE:
4310         case FOREACH:
4311         case AT:
4312         case BANG:
4313         case TILDE:
4314         case PLUS_PLUS:
4315         case MINUS_MINUS:
4316         case PLUS:
4317         case MINUS:
4318         case BIT_AND:
4319         case INTEGER_LITERAL:
4320         case FLOATING_POINT_LITERAL:
4321         case STRING_LITERAL:
4322         case DOUBLEQUOTE:
4323         case DOLLAR:
4324         case IDENTIFIER:
4325         case LPAREN:
4326         case LBRACE:
4327         case SEMICOLON:
4328           ;
4329           break;
4330         default:
4331           jj_la1[105] = jj_gen;
4332           break label_32;
4333         }
4334         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
4335         case IF:
4336         case ARRAY:
4337         case BREAK:
4338         case LIST:
4339         case PRINT:
4340         case ECHO:
4341         case INCLUDE:
4342         case REQUIRE:
4343         case INCLUDE_ONCE:
4344         case REQUIRE_ONCE:
4345         case GLOBAL:
4346         case DEFINE:
4347         case STATIC:
4348         case CONTINUE:
4349         case DO:
4350         case FOR:
4351         case NEW:
4352         case NULL:
4353         case RETURN:
4354         case SWITCH:
4355         case TRUE:
4356         case FALSE:
4357         case WHILE:
4358         case FOREACH:
4359         case AT:
4360         case BANG:
4361         case TILDE:
4362         case PLUS_PLUS:
4363         case MINUS_MINUS:
4364         case PLUS:
4365         case MINUS:
4366         case BIT_AND:
4367         case INTEGER_LITERAL:
4368         case FLOATING_POINT_LITERAL:
4369         case STRING_LITERAL:
4370         case DOUBLEQUOTE:
4371         case DOLLAR:
4372         case IDENTIFIER:
4373         case LPAREN:
4374         case LBRACE:
4375         case SEMICOLON:
4376           statement = Statement();
4377                               stmts.add(statement);
4378           break;
4379         case PHPEND:
4380           statement = htmlBlock();
4381                               if (statement != null) {stmts.add(statement);}
4382           break;
4383         default:
4384           jj_la1[106] = jj_gen;
4385           jj_consume_token(-1);
4386           throw new ParseException();
4387         }
4388       }
4389     endStatements = SimpleCharStream.getPosition();
4390       label_33:
4391       while (true) {
4392         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
4393         case ELSEIF:
4394           ;
4395           break;
4396         default:
4397           jj_la1[107] = jj_gen;
4398           break label_33;
4399         }
4400         elseifStatement = ElseIfStatementColon();
4401                                               elseIfList.add(elseifStatement);
4402       }
4403       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
4404       case ELSE:
4405         elseStatement = ElseStatementColon();
4406         break;
4407       default:
4408         jj_la1[108] = jj_gen;
4409         ;
4410       }
4411    try {
4412   setMarker(fileToParse,
4413             "Ugly syntax detected, you should if () {...} instead of if (): ... endif;",
4414             start,
4415             end,
4416             INFO,
4417             "Line " + token.beginLine);
4418   } catch (CoreException e) {
4419     PHPeclipsePlugin.log(e);
4420   }
4421       try {
4422         jj_consume_token(ENDIF);
4423       } catch (ParseException e) {
4424     errorMessage = "'endif' expected";
4425     errorLevel   = ERROR;
4426     errorStart = SimpleCharStream.getPosition() - e.currentToken.next.image.length() + 1;
4427     errorEnd   = SimpleCharStream.getPosition() + 1;
4428     {if (true) throw e;}
4429       }
4430       try {
4431         jj_consume_token(SEMICOLON);
4432       } catch (ParseException e) {
4433     errorMessage = "';' expected after 'endif' keyword";
4434     errorLevel   = ERROR;
4435     errorStart = SimpleCharStream.getPosition() - e.currentToken.next.image.length() + 1;
4436     errorEnd   = SimpleCharStream.getPosition() + 1;
4437     {if (true) throw e;}
4438       }
4439     elseIfs = new ElseIf[elseIfList.size()];
4440     elseIfList.toArray(elseIfs);
4441     if (stmts.size() == 1) {
4442       {if (true) return new IfStatement(condition,
4443                              (Statement) stmts.get(0),
4444                               elseIfs,
4445                               elseStatement,
4446                               pos,
4447                               SimpleCharStream.getPosition());}
4448     } else {
4449       statementsArray = new Statement[stmts.size()];
4450       stmts.toArray(statementsArray);
4451       {if (true) return new IfStatement(condition,
4452                              new Block(statementsArray,pos,endStatements),
4453                              elseIfs,
4454                              elseStatement,
4455                              pos,
4456                              SimpleCharStream.getPosition());}
4457     }
4458       break;
4459     case PHPEND:
4460     case IF:
4461     case ARRAY:
4462     case BREAK:
4463     case LIST:
4464     case PRINT:
4465     case ECHO:
4466     case INCLUDE:
4467     case REQUIRE:
4468     case INCLUDE_ONCE:
4469     case REQUIRE_ONCE:
4470     case GLOBAL:
4471     case DEFINE:
4472     case STATIC:
4473     case CONTINUE:
4474     case DO:
4475     case FOR:
4476     case NEW:
4477     case NULL:
4478     case RETURN:
4479     case SWITCH:
4480     case TRUE:
4481     case FALSE:
4482     case WHILE:
4483     case FOREACH:
4484     case AT:
4485     case BANG:
4486     case TILDE:
4487     case PLUS_PLUS:
4488     case MINUS_MINUS:
4489     case PLUS:
4490     case MINUS:
4491     case BIT_AND:
4492     case INTEGER_LITERAL:
4493     case FLOATING_POINT_LITERAL:
4494     case STRING_LITERAL:
4495     case DOUBLEQUOTE:
4496     case DOLLAR:
4497     case IDENTIFIER:
4498     case LPAREN:
4499     case LBRACE:
4500     case SEMICOLON:
4501       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
4502       case IF:
4503       case ARRAY:
4504       case BREAK:
4505       case LIST:
4506       case PRINT:
4507       case ECHO:
4508       case INCLUDE:
4509       case REQUIRE:
4510       case INCLUDE_ONCE:
4511       case REQUIRE_ONCE:
4512       case GLOBAL:
4513       case DEFINE:
4514       case STATIC:
4515       case CONTINUE:
4516       case DO:
4517       case FOR:
4518       case NEW:
4519       case NULL:
4520       case RETURN:
4521       case SWITCH:
4522       case TRUE:
4523       case FALSE:
4524       case WHILE:
4525       case FOREACH:
4526       case AT:
4527       case BANG:
4528       case TILDE:
4529       case PLUS_PLUS:
4530       case MINUS_MINUS:
4531       case PLUS:
4532       case MINUS:
4533       case BIT_AND:
4534       case INTEGER_LITERAL:
4535       case FLOATING_POINT_LITERAL:
4536       case STRING_LITERAL:
4537       case DOUBLEQUOTE:
4538       case DOLLAR:
4539       case IDENTIFIER:
4540       case LPAREN:
4541       case LBRACE:
4542       case SEMICOLON:
4543         stmt = Statement();
4544         break;
4545       case PHPEND:
4546         stmt = htmlBlock();
4547         break;
4548       default:
4549         jj_la1[109] = jj_gen;
4550         jj_consume_token(-1);
4551         throw new ParseException();
4552       }
4553       label_34:
4554       while (true) {
4555         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
4556         case ELSEIF:
4557           ;
4558           break;
4559         default:
4560           jj_la1[110] = jj_gen;
4561           break label_34;
4562         }
4563         elseifStatement = ElseIfStatement();
4564                                                       elseIfList.add(elseifStatement);
4565       }
4566       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
4567       case ELSE:
4568         jj_consume_token(ELSE);
4569         try {
4570        pos = SimpleCharStream.getPosition();
4571           statement = Statement();
4572        elseStatement = new Else(statement,pos,SimpleCharStream.getPosition());
4573         } catch (ParseException e) {
4574       if (errorMessage != null) {
4575         {if (true) throw e;}
4576       }
4577       errorMessage = "unexpected token '"+e.currentToken.next.image+"', a statement was expected";
4578       errorLevel   = ERROR;
4579       errorStart = SimpleCharStream.getPosition() - e.currentToken.next.image.length() + 1;
4580       errorEnd   = SimpleCharStream.getPosition() + 1;
4581       {if (true) throw e;}
4582         }
4583         break;
4584       default:
4585         jj_la1[111] = jj_gen;
4586         ;
4587       }
4588     elseIfs = new ElseIf[elseIfList.size()];
4589     elseIfList.toArray(elseIfs);
4590     {if (true) return new IfStatement(condition,
4591                            stmt,
4592                            elseIfs,
4593                            elseStatement,
4594                            pos,
4595                            SimpleCharStream.getPosition());}
4596       break;
4597     default:
4598       jj_la1[112] = jj_gen;
4599       jj_consume_token(-1);
4600       throw new ParseException();
4601     }
4602     throw new Error("Missing return statement in function");
4603   }
4604
4605   static final public ElseIf ElseIfStatementColon() throws ParseException {
4606   final Expression condition;
4607   Statement statement;
4608   final ArrayList list = new ArrayList();
4609   final Token elseifToken;
4610     elseifToken = jj_consume_token(ELSEIF);
4611     condition = Condition("elseif");
4612     jj_consume_token(COLON);
4613     label_35:
4614     while (true) {
4615       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
4616       case PHPEND:
4617       case IF:
4618       case ARRAY:
4619       case BREAK:
4620       case LIST:
4621       case PRINT:
4622       case ECHO:
4623       case INCLUDE:
4624       case REQUIRE:
4625       case INCLUDE_ONCE:
4626       case REQUIRE_ONCE:
4627       case GLOBAL:
4628       case DEFINE:
4629       case STATIC:
4630       case CONTINUE:
4631       case DO:
4632       case FOR:
4633       case NEW:
4634       case NULL:
4635       case RETURN:
4636       case SWITCH:
4637       case TRUE:
4638       case FALSE:
4639       case WHILE:
4640       case FOREACH:
4641       case AT:
4642       case BANG:
4643       case TILDE:
4644       case PLUS_PLUS:
4645       case MINUS_MINUS:
4646       case PLUS:
4647       case MINUS:
4648       case BIT_AND:
4649       case INTEGER_LITERAL:
4650       case FLOATING_POINT_LITERAL:
4651       case STRING_LITERAL:
4652       case DOUBLEQUOTE:
4653       case DOLLAR:
4654       case IDENTIFIER:
4655       case LPAREN:
4656       case LBRACE:
4657       case SEMICOLON:
4658         ;
4659         break;
4660       default:
4661         jj_la1[113] = jj_gen;
4662         break label_35;
4663       }
4664       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
4665       case IF:
4666       case ARRAY:
4667       case BREAK:
4668       case LIST:
4669       case PRINT:
4670       case ECHO:
4671       case INCLUDE:
4672       case REQUIRE:
4673       case INCLUDE_ONCE:
4674       case REQUIRE_ONCE:
4675       case GLOBAL:
4676       case DEFINE:
4677       case STATIC:
4678       case CONTINUE:
4679       case DO:
4680       case FOR:
4681       case NEW:
4682       case NULL:
4683       case RETURN:
4684       case SWITCH:
4685       case TRUE:
4686       case FALSE:
4687       case WHILE:
4688       case FOREACH:
4689       case AT:
4690       case BANG:
4691       case TILDE:
4692       case PLUS_PLUS:
4693       case MINUS_MINUS:
4694       case PLUS:
4695       case MINUS:
4696       case BIT_AND:
4697       case INTEGER_LITERAL:
4698       case FLOATING_POINT_LITERAL:
4699       case STRING_LITERAL:
4700       case DOUBLEQUOTE:
4701       case DOLLAR:
4702       case IDENTIFIER:
4703       case LPAREN:
4704       case LBRACE:
4705       case SEMICOLON:
4706         statement = Statement();
4707                                       list.add(statement);
4708         break;
4709       case PHPEND:
4710         statement = htmlBlock();
4711                                       if (statement != null) {list.add(statement);}
4712         break;
4713       default:
4714         jj_la1[114] = jj_gen;
4715         jj_consume_token(-1);
4716         throw new ParseException();
4717       }
4718     }
4719   final int sizeList = list.size();
4720   final Statement[] stmtsArray = new Statement[sizeList];
4721   list.toArray(stmtsArray);
4722   {if (true) return new ElseIf(condition,stmtsArray ,
4723                     elseifToken.sourceStart,
4724                     stmtsArray[sizeList-1].sourceEnd);}
4725     throw new Error("Missing return statement in function");
4726   }
4727
4728   static final public Else ElseStatementColon() throws ParseException {
4729   Statement statement;
4730   final ArrayList list = new ArrayList();
4731   final Token elseToken;
4732     elseToken = jj_consume_token(ELSE);
4733     jj_consume_token(COLON);
4734     label_36:
4735     while (true) {
4736       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
4737       case PHPEND:
4738       case IF:
4739       case ARRAY:
4740       case BREAK:
4741       case LIST:
4742       case PRINT:
4743       case ECHO:
4744       case INCLUDE:
4745       case REQUIRE:
4746       case INCLUDE_ONCE:
4747       case REQUIRE_ONCE:
4748       case GLOBAL:
4749       case DEFINE:
4750       case STATIC:
4751       case CONTINUE:
4752       case DO:
4753       case FOR:
4754       case NEW:
4755       case NULL:
4756       case RETURN:
4757       case SWITCH:
4758       case TRUE:
4759       case FALSE:
4760       case WHILE:
4761       case FOREACH:
4762       case AT:
4763       case BANG:
4764       case TILDE:
4765       case PLUS_PLUS:
4766       case MINUS_MINUS:
4767       case PLUS:
4768       case MINUS:
4769       case BIT_AND:
4770       case INTEGER_LITERAL:
4771       case FLOATING_POINT_LITERAL:
4772       case STRING_LITERAL:
4773       case DOUBLEQUOTE:
4774       case DOLLAR:
4775       case IDENTIFIER:
4776       case LPAREN:
4777       case LBRACE:
4778       case SEMICOLON:
4779         ;
4780         break;
4781       default:
4782         jj_la1[115] = jj_gen;
4783         break label_36;
4784       }
4785       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
4786       case IF:
4787       case ARRAY:
4788       case BREAK:
4789       case LIST:
4790       case PRINT:
4791       case ECHO:
4792       case INCLUDE:
4793       case REQUIRE:
4794       case INCLUDE_ONCE:
4795       case REQUIRE_ONCE:
4796       case GLOBAL:
4797       case DEFINE:
4798       case STATIC:
4799       case CONTINUE:
4800       case DO:
4801       case FOR:
4802       case NEW:
4803       case NULL:
4804       case RETURN:
4805       case SWITCH:
4806       case TRUE:
4807       case FALSE:
4808       case WHILE:
4809       case FOREACH:
4810       case AT:
4811       case BANG:
4812       case TILDE:
4813       case PLUS_PLUS:
4814       case MINUS_MINUS:
4815       case PLUS:
4816       case MINUS:
4817       case BIT_AND:
4818       case INTEGER_LITERAL:
4819       case FLOATING_POINT_LITERAL:
4820       case STRING_LITERAL:
4821       case DOUBLEQUOTE:
4822       case DOLLAR:
4823       case IDENTIFIER:
4824       case LPAREN:
4825       case LBRACE:
4826       case SEMICOLON:
4827         statement = Statement();
4828                                                          list.add(statement);
4829         break;
4830       case PHPEND:
4831         statement = htmlBlock();
4832                                              if (statement != null) {list.add(statement);}
4833         break;
4834       default:
4835         jj_la1[116] = jj_gen;
4836         jj_consume_token(-1);
4837         throw new ParseException();
4838       }
4839     }
4840   final int sizeList = list.size();
4841   final Statement[] stmtsArray = new Statement[sizeList];
4842   list.toArray(stmtsArray);
4843   {if (true) return new Else(stmtsArray,elseToken.sourceStart,stmtsArray[sizeList-1].sourceEnd);}
4844     throw new Error("Missing return statement in function");
4845   }
4846
4847   static final public ElseIf ElseIfStatement() throws ParseException {
4848   final Expression condition;
4849   //final Statement statement;
4850   final Token elseifToken;
4851   final Statement[] statement = new Statement[1];
4852     elseifToken = jj_consume_token(ELSEIF);
4853     condition = Condition("elseif");
4854     statement[0] = Statement();
4855   {if (true) return new ElseIf(condition,statement,elseifToken.sourceStart,statement[0].sourceEnd);}
4856     throw new Error("Missing return statement in function");
4857   }
4858
4859   static final public WhileStatement WhileStatement() throws ParseException {
4860   final Expression condition;
4861   final Statement action;
4862   final Token whileToken;
4863     whileToken = jj_consume_token(WHILE);
4864     condition = Condition("while");
4865     action = WhileStatement0(whileToken.sourceStart,whileToken.sourceEnd);
4866      {if (true) return new WhileStatement(condition,action,whileToken.sourceStart,action.sourceEnd);}
4867     throw new Error("Missing return statement in function");
4868   }
4869
4870   static final public Statement WhileStatement0(final int start, final int end) throws ParseException {
4871   Statement statement;
4872   final ArrayList stmts = new ArrayList();
4873   final int pos = SimpleCharStream.getPosition();
4874     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
4875     case COLON:
4876       jj_consume_token(COLON);
4877       label_37:
4878       while (true) {
4879         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
4880         case IF:
4881         case ARRAY:
4882         case BREAK:
4883         case LIST:
4884         case PRINT:
4885         case ECHO:
4886         case INCLUDE:
4887         case REQUIRE:
4888         case INCLUDE_ONCE:
4889         case REQUIRE_ONCE:
4890         case GLOBAL:
4891         case DEFINE:
4892         case STATIC:
4893         case CONTINUE:
4894         case DO:
4895         case FOR:
4896         case NEW:
4897         case NULL:
4898         case RETURN:
4899         case SWITCH:
4900         case TRUE:
4901         case FALSE:
4902         case WHILE:
4903         case FOREACH:
4904         case AT:
4905         case BANG:
4906         case TILDE:
4907         case PLUS_PLUS:
4908         case MINUS_MINUS:
4909         case PLUS:
4910         case MINUS:
4911         case BIT_AND:
4912         case INTEGER_LITERAL:
4913         case FLOATING_POINT_LITERAL:
4914         case STRING_LITERAL:
4915         case DOUBLEQUOTE:
4916         case DOLLAR:
4917         case IDENTIFIER:
4918         case LPAREN:
4919         case LBRACE:
4920         case SEMICOLON:
4921           ;
4922           break;
4923         default:
4924           jj_la1[117] = jj_gen;
4925           break label_37;
4926         }
4927         statement = Statement();
4928                                     stmts.add(statement);
4929       }
4930    try {
4931   setMarker(fileToParse,
4932             "Ugly syntax detected, you should while () {...} instead of while (): ... endwhile;",
4933             start,
4934             end,
4935             INFO,
4936             "Line " + token.beginLine);
4937   } catch (CoreException e) {
4938     PHPeclipsePlugin.log(e);
4939   }
4940       try {
4941         jj_consume_token(ENDWHILE);
4942       } catch (ParseException e) {
4943     errorMessage = "'endwhile' expected";
4944     errorLevel   = ERROR;
4945     errorStart = SimpleCharStream.getPosition() - e.currentToken.next.image.length() + 1;
4946     errorEnd   = SimpleCharStream.getPosition() + 1;
4947     {if (true) throw e;}
4948       }
4949       try {
4950         jj_consume_token(SEMICOLON);
4951     final Statement[] stmtsArray = new Statement[stmts.size()];
4952     stmts.toArray(stmtsArray);
4953     {if (true) return new Block(stmtsArray,pos,SimpleCharStream.getPosition());}
4954       } catch (ParseException e) {
4955     errorMessage = "';' expected after 'endwhile' keyword";
4956     errorLevel   = ERROR;
4957     errorStart = SimpleCharStream.getPosition() - e.currentToken.next.image.length() + 1;
4958     errorEnd   = SimpleCharStream.getPosition() + 1;
4959     {if (true) throw e;}
4960       }
4961       break;
4962     case IF:
4963     case ARRAY:
4964     case BREAK:
4965     case LIST:
4966     case PRINT:
4967     case ECHO:
4968     case INCLUDE:
4969     case REQUIRE:
4970     case INCLUDE_ONCE:
4971     case REQUIRE_ONCE:
4972     case GLOBAL:
4973     case DEFINE:
4974     case STATIC:
4975     case CONTINUE:
4976     case DO:
4977     case FOR:
4978     case NEW:
4979     case NULL:
4980     case RETURN:
4981     case SWITCH:
4982     case TRUE:
4983     case FALSE:
4984     case WHILE:
4985     case FOREACH:
4986     case AT:
4987     case BANG:
4988     case TILDE:
4989     case PLUS_PLUS:
4990     case MINUS_MINUS:
4991     case PLUS:
4992     case MINUS:
4993     case BIT_AND:
4994     case INTEGER_LITERAL:
4995     case FLOATING_POINT_LITERAL:
4996     case STRING_LITERAL:
4997     case DOUBLEQUOTE:
4998     case DOLLAR:
4999     case IDENTIFIER:
5000     case LPAREN:
5001     case LBRACE:
5002     case SEMICOLON:
5003       statement = Statement();
5004    {if (true) return statement;}
5005       break;
5006     default:
5007       jj_la1[118] = jj_gen;
5008       jj_consume_token(-1);
5009       throw new ParseException();
5010     }
5011     throw new Error("Missing return statement in function");
5012   }
5013
5014   static final public DoStatement DoStatement() throws ParseException {
5015   final Statement action;
5016   final Expression condition;
5017   final Token token;
5018   Token token2 = null;
5019     token = jj_consume_token(DO);
5020     action = Statement();
5021     jj_consume_token(WHILE);
5022     condition = Condition("while");
5023     try {
5024       token2 = jj_consume_token(SEMICOLON);
5025     } catch (ParseException e) {
5026     errorMessage = "unexpected token : '"+ e.currentToken.next.image +"'. A ';' was expected";
5027     errorLevel   = ERROR;
5028     errorStart = condition.sourceEnd+1;
5029     errorEnd   = condition.sourceEnd+1;
5030     processParseExceptionDebug(e);
5031     }
5032     if (token2 == null) {
5033       {if (true) return new DoStatement(condition,action,token.sourceStart,condition.sourceEnd);}
5034     }
5035     {if (true) return new DoStatement(condition,action,token.sourceStart,token2.sourceEnd);}
5036     throw new Error("Missing return statement in function");
5037   }
5038
5039   static final public ForeachStatement ForeachStatement() throws ParseException {
5040   Statement statement = null;
5041   Expression expression = null;
5042   ArrayVariableDeclaration variable = null;
5043   Token foreachToken;
5044   Token lparenToken = null;
5045   Token asToken = null;
5046   Token rparenToken = null;
5047   int pos;
5048     foreachToken = jj_consume_token(FOREACH);
5049     try {
5050       lparenToken = jj_consume_token(LPAREN);
5051      pos = lparenToken.sourceEnd+1;
5052     } catch (ParseException e) {
5053     errorMessage = "'(' expected after 'foreach' keyword";
5054     errorLevel   = ERROR;
5055     errorStart = foreachToken.sourceEnd+1;
5056     errorEnd   = foreachToken.sourceEnd+1;
5057     processParseExceptionDebug(e);
5058     {pos = foreachToken.sourceEnd+1;}
5059     }
5060     try {
5061       expression = Expression();
5062      pos = expression.sourceEnd+1;
5063     } catch (ParseException e) {
5064     errorMessage = "variable expected";
5065     errorLevel   = ERROR;
5066     errorStart = pos;
5067     errorEnd   = pos;
5068     processParseExceptionDebug(e);
5069     }
5070     try {
5071       asToken = jj_consume_token(AS);
5072      pos = asToken.sourceEnd+1;
5073     } catch (ParseException e) {
5074     errorMessage = "'as' expected";
5075     errorLevel   = ERROR;
5076     errorStart = pos;
5077     errorEnd   = pos;
5078     processParseExceptionDebug(e);
5079     }
5080     try {
5081       variable = ArrayVariable();
5082      pos = variable.sourceEnd+1;
5083     } catch (ParseException e) {
5084     if (errorMessage != null) {if (true) throw e;}
5085     errorMessage = "variable expected";
5086     errorLevel   = ERROR;
5087     errorStart = pos;
5088     errorEnd   = pos;
5089     processParseExceptionDebug(e);
5090     }
5091     try {
5092       rparenToken = jj_consume_token(RPAREN);
5093      pos = rparenToken.sourceEnd+1;
5094     } catch (ParseException e) {
5095     errorMessage = "')' expected after 'foreach' keyword";
5096     errorLevel   = ERROR;
5097     errorStart = pos;
5098     errorEnd   = pos;
5099     processParseExceptionDebug(e);
5100     }
5101     try {
5102       statement = Statement();
5103      pos = rparenToken.sourceEnd+1;
5104     } catch (ParseException e) {
5105     if (errorMessage != null) {if (true) throw e;}
5106     errorMessage = "statement expected";
5107     errorLevel   = ERROR;
5108     errorStart = pos;
5109     errorEnd   = pos;
5110     processParseExceptionDebug(e);
5111     }
5112    {if (true) return new ForeachStatement(expression,
5113                                variable,
5114                                statement,
5115                                foreachToken.sourceStart,
5116                                statement.sourceEnd);}
5117     throw new Error("Missing return statement in function");
5118   }
5119
5120 /**
5121  * a for declaration.
5122  * @return a node representing the for statement
5123  */
5124   static final public ForStatement ForStatement() throws ParseException {
5125 final Token token,tokenEndFor,token2,tokenColon;
5126 int pos;
5127 Expression[] initializations = null;
5128 Expression condition = null;
5129 Expression[] increments = null;
5130 Statement action;
5131 final ArrayList list = new ArrayList();
5132     token = jj_consume_token(FOR);
5133     try {
5134       jj_consume_token(LPAREN);
5135     } catch (ParseException e) {
5136     errorMessage = "'(' expected after 'for' keyword";
5137     errorLevel   = ERROR;
5138     errorStart = token.sourceEnd;
5139     errorEnd   = token.sourceEnd +1;
5140     processParseExceptionDebug(e);
5141     }
5142     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
5143     case ARRAY:
5144     case LIST:
5145     case PRINT:
5146     case NEW:
5147     case NULL:
5148     case TRUE:
5149     case FALSE:
5150     case AT:
5151     case BANG:
5152     case TILDE:
5153     case PLUS_PLUS:
5154     case MINUS_MINUS:
5155     case PLUS:
5156     case MINUS:
5157     case BIT_AND:
5158     case INTEGER_LITERAL:
5159     case FLOATING_POINT_LITERAL:
5160     case STRING_LITERAL:
5161     case DOUBLEQUOTE:
5162     case DOLLAR:
5163     case IDENTIFIER:
5164     case LPAREN:
5165       initializations = ForInit();
5166       break;
5167     default:
5168       jj_la1[119] = jj_gen;
5169       ;
5170     }
5171     jj_consume_token(SEMICOLON);
5172     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
5173     case ARRAY:
5174     case LIST:
5175     case PRINT:
5176     case NEW:
5177     case NULL:
5178     case TRUE:
5179     case FALSE:
5180     case AT:
5181     case BANG:
5182     case TILDE:
5183     case PLUS_PLUS:
5184     case MINUS_MINUS:
5185     case PLUS:
5186     case MINUS:
5187     case BIT_AND:
5188     case INTEGER_LITERAL:
5189     case FLOATING_POINT_LITERAL:
5190     case STRING_LITERAL:
5191     case DOUBLEQUOTE:
5192     case DOLLAR:
5193     case IDENTIFIER:
5194     case LPAREN:
5195       condition = Expression();
5196       break;
5197     default:
5198       jj_la1[120] = jj_gen;
5199       ;
5200     }
5201     jj_consume_token(SEMICOLON);
5202     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
5203     case ARRAY:
5204     case LIST:
5205     case PRINT:
5206     case NEW:
5207     case NULL:
5208     case TRUE:
5209     case FALSE:
5210     case AT:
5211     case BANG:
5212     case TILDE:
5213     case PLUS_PLUS:
5214     case MINUS_MINUS:
5215     case PLUS:
5216     case MINUS:
5217     case BIT_AND:
5218     case INTEGER_LITERAL:
5219     case FLOATING_POINT_LITERAL:
5220     case STRING_LITERAL:
5221     case DOUBLEQUOTE:
5222     case DOLLAR:
5223     case IDENTIFIER:
5224     case LPAREN:
5225       increments = StatementExpressionList();
5226       break;
5227     default:
5228       jj_la1[121] = jj_gen;
5229       ;
5230     }
5231     jj_consume_token(RPAREN);
5232     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
5233     case IF:
5234     case ARRAY:
5235     case BREAK:
5236     case LIST:
5237     case PRINT:
5238     case ECHO:
5239     case INCLUDE:
5240     case REQUIRE:
5241     case INCLUDE_ONCE:
5242     case REQUIRE_ONCE:
5243     case GLOBAL:
5244     case DEFINE:
5245     case STATIC:
5246     case CONTINUE:
5247     case DO:
5248     case FOR:
5249     case NEW:
5250     case NULL:
5251     case RETURN:
5252     case SWITCH:
5253     case TRUE:
5254     case FALSE:
5255     case WHILE:
5256     case FOREACH:
5257     case AT:
5258     case BANG:
5259     case TILDE:
5260     case PLUS_PLUS:
5261     case MINUS_MINUS:
5262     case PLUS:
5263     case MINUS:
5264     case BIT_AND:
5265     case INTEGER_LITERAL:
5266     case FLOATING_POINT_LITERAL:
5267     case STRING_LITERAL:
5268     case DOUBLEQUOTE:
5269     case DOLLAR:
5270     case IDENTIFIER:
5271     case LPAREN:
5272     case LBRACE:
5273     case SEMICOLON:
5274       action = Statement();
5275        {if (true) return new ForStatement(initializations,
5276                                condition,
5277                                increments,
5278                                action,
5279                                token.sourceStart,
5280                                action.sourceEnd);}
5281       break;
5282     case COLON:
5283       tokenColon = jj_consume_token(COLON);
5284                             pos = tokenColon.sourceEnd+1;
5285       label_38:
5286       while (true) {
5287         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
5288         case IF:
5289         case ARRAY:
5290         case BREAK:
5291         case LIST:
5292         case PRINT:
5293         case ECHO:
5294         case INCLUDE:
5295         case REQUIRE:
5296         case INCLUDE_ONCE:
5297         case REQUIRE_ONCE:
5298         case GLOBAL:
5299         case DEFINE:
5300         case STATIC:
5301         case CONTINUE:
5302         case DO:
5303         case FOR:
5304         case NEW:
5305         case NULL:
5306         case RETURN:
5307         case SWITCH:
5308         case TRUE:
5309         case FALSE:
5310         case WHILE:
5311         case FOREACH:
5312         case AT:
5313         case BANG:
5314         case TILDE:
5315         case PLUS_PLUS:
5316         case MINUS_MINUS:
5317         case PLUS:
5318         case MINUS:
5319         case BIT_AND:
5320         case INTEGER_LITERAL:
5321         case FLOATING_POINT_LITERAL:
5322         case STRING_LITERAL:
5323         case DOUBLEQUOTE:
5324         case DOLLAR:
5325         case IDENTIFIER:
5326         case LPAREN:
5327         case LBRACE:
5328         case SEMICOLON:
5329           ;
5330           break;
5331         default:
5332           jj_la1[122] = jj_gen;
5333           break label_38;
5334         }
5335         action = Statement();
5336                              list.add(action);pos = action.sourceEnd+1;
5337       }
5338         try {
5339         setMarker(fileToParse,
5340                   "Ugly syntax detected, you should for () {...} instead of for (): ... endfor;",
5341                   token.sourceStart,
5342                   token.sourceEnd,
5343                   INFO,
5344                   "Line " + token.beginLine);
5345         } catch (CoreException e) {
5346           PHPeclipsePlugin.log(e);
5347         }
5348       try {
5349         tokenEndFor = jj_consume_token(ENDFOR);
5350          pos = tokenEndFor.sourceEnd+1;
5351       } catch (ParseException e) {
5352         errorMessage = "'endfor' expected";
5353         errorLevel   = ERROR;
5354         errorStart = pos;
5355         errorEnd   = pos;
5356         processParseExceptionDebug(e);
5357       }
5358       try {
5359         token2 = jj_consume_token(SEMICOLON);
5360          pos = token2.sourceEnd+1;
5361       } catch (ParseException e) {
5362         errorMessage = "';' expected after 'endfor' keyword";
5363         errorLevel   = ERROR;
5364         errorStart = pos;
5365         errorEnd   = pos;
5366         processParseExceptionDebug(e);
5367       }
5368       final Statement[] stmtsArray = new Statement[list.size()];
5369       list.toArray(stmtsArray);
5370       {if (true) return new ForStatement(initializations,
5371                               condition,
5372                               increments,
5373                               new Block(stmtsArray,
5374                                         stmtsArray[0].sourceStart,
5375                                         stmtsArray[stmtsArray.length-1].sourceEnd),
5376                               token.sourceStart,
5377                               pos);}
5378       break;
5379     default:
5380       jj_la1[123] = jj_gen;
5381       jj_consume_token(-1);
5382       throw new ParseException();
5383     }
5384     throw new Error("Missing return statement in function");
5385   }
5386
5387   static final public Expression[] ForInit() throws ParseException {
5388   final Expression[] exprs;
5389     if (jj_2_5(2147483647)) {
5390       exprs = LocalVariableDeclaration();
5391    {if (true) return exprs;}
5392     } else {
5393       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
5394       case ARRAY:
5395       case LIST:
5396       case PRINT:
5397       case NEW:
5398       case NULL:
5399       case TRUE:
5400       case FALSE:
5401       case AT:
5402       case BANG:
5403       case TILDE:
5404       case PLUS_PLUS:
5405       case MINUS_MINUS:
5406       case PLUS:
5407       case MINUS:
5408       case BIT_AND:
5409       case INTEGER_LITERAL:
5410       case FLOATING_POINT_LITERAL:
5411       case STRING_LITERAL:
5412       case DOUBLEQUOTE:
5413       case DOLLAR:
5414       case IDENTIFIER:
5415       case LPAREN:
5416         exprs = StatementExpressionList();
5417    {if (true) return exprs;}
5418         break;
5419       default:
5420         jj_la1[124] = jj_gen;
5421         jj_consume_token(-1);
5422         throw new ParseException();
5423       }
5424     }
5425     throw new Error("Missing return statement in function");
5426   }
5427
5428   static final public Expression[] StatementExpressionList() throws ParseException {
5429   final ArrayList list = new ArrayList();
5430   final Expression expr;
5431     expr = Expression();
5432                          list.add(expr);
5433     label_39:
5434     while (true) {
5435       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
5436       case COMMA:
5437         ;
5438         break;
5439       default:
5440         jj_la1[125] = jj_gen;
5441         break label_39;
5442       }
5443       jj_consume_token(COMMA);
5444       Expression();
5445                          list.add(expr);
5446     }
5447     final Expression[] exprsArray = new Expression[list.size()];
5448     list.toArray(exprsArray);
5449     {if (true) return exprsArray;}
5450     throw new Error("Missing return statement in function");
5451   }
5452
5453   static final public Continue ContinueStatement() throws ParseException {
5454   Expression expr = null;
5455   final Token token;
5456   Token token2 = null;
5457     token = jj_consume_token(CONTINUE);
5458     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
5459     case ARRAY:
5460     case LIST:
5461     case PRINT:
5462     case NEW:
5463     case NULL:
5464     case TRUE:
5465     case FALSE:
5466     case AT:
5467     case BANG:
5468     case TILDE:
5469     case PLUS_PLUS:
5470     case MINUS_MINUS:
5471     case PLUS:
5472     case MINUS:
5473     case BIT_AND:
5474     case INTEGER_LITERAL:
5475     case FLOATING_POINT_LITERAL:
5476     case STRING_LITERAL:
5477     case DOUBLEQUOTE:
5478     case DOLLAR:
5479     case IDENTIFIER:
5480     case LPAREN:
5481       expr = Expression();
5482       break;
5483     default:
5484       jj_la1[126] = jj_gen;
5485       ;
5486     }
5487     try {
5488       token2 = jj_consume_token(SEMICOLON);
5489     } catch (ParseException e) {
5490     errorMessage = "';' expected after 'continue' statement";
5491     errorLevel   = ERROR;
5492     if (expr == null) {
5493       errorStart = token.sourceEnd+1;
5494       errorEnd   = token.sourceEnd+1;
5495     } else {
5496       errorStart = expr.sourceEnd+1;
5497       errorEnd   = expr.sourceEnd+1;
5498     }
5499     processParseExceptionDebug(e);
5500     }
5501     if (token2 == null) {
5502       if (expr == null) {
5503         {if (true) return new Continue(expr,token.sourceStart,token.sourceEnd);}
5504       }
5505       {if (true) return new Continue(expr,token.sourceStart,expr.sourceEnd);}
5506     }
5507     {if (true) return new Continue(expr,token.sourceStart,token2.sourceEnd);}
5508     throw new Error("Missing return statement in function");
5509   }
5510
5511   static final public ReturnStatement ReturnStatement() throws ParseException {
5512   Expression expr = null;
5513   final Token token;
5514   Token token2 = null;
5515     token = jj_consume_token(RETURN);
5516     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
5517     case ARRAY:
5518     case LIST:
5519     case PRINT:
5520     case NEW:
5521     case NULL:
5522     case TRUE:
5523     case FALSE:
5524     case AT:
5525     case BANG:
5526     case TILDE:
5527     case PLUS_PLUS:
5528     case MINUS_MINUS:
5529     case PLUS:
5530     case MINUS:
5531     case BIT_AND:
5532     case INTEGER_LITERAL:
5533     case FLOATING_POINT_LITERAL:
5534     case STRING_LITERAL:
5535     case DOUBLEQUOTE:
5536     case DOLLAR:
5537     case IDENTIFIER:
5538     case LPAREN:
5539       expr = Expression();
5540       break;
5541     default:
5542       jj_la1[127] = jj_gen;
5543       ;
5544     }
5545     try {
5546       token2 = jj_consume_token(SEMICOLON);
5547     } catch (ParseException e) {
5548     errorMessage = "';' expected after 'return' statement";
5549     errorLevel   = ERROR;
5550     if (expr == null) {
5551       errorStart = token.sourceEnd+1;
5552       errorEnd   = token.sourceEnd+1;
5553     } else {
5554       errorStart = expr.sourceEnd+1;
5555       errorEnd   = expr.sourceEnd+1;
5556     }
5557     processParseExceptionDebug(e);
5558     }
5559     if (token2 == null) {
5560       if (expr == null) {
5561         {if (true) return new ReturnStatement(expr,token.sourceStart,token.sourceEnd);}
5562       }
5563       {if (true) return new ReturnStatement(expr,token.sourceStart,expr.sourceEnd);}
5564     }
5565     {if (true) return new ReturnStatement(expr,token.sourceStart,token2.sourceEnd);}
5566     throw new Error("Missing return statement in function");
5567   }
5568
5569   static final private boolean jj_2_1(int xla) {
5570     jj_la = xla; jj_lastpos = jj_scanpos = token;
5571     boolean retval = !jj_3_1();
5572     jj_save(0, xla);
5573     return retval;
5574   }
5575
5576   static final private boolean jj_2_2(int xla) {
5577     jj_la = xla; jj_lastpos = jj_scanpos = token;
5578     boolean retval = !jj_3_2();
5579     jj_save(1, xla);
5580     return retval;
5581   }
5582
5583   static final private boolean jj_2_3(int xla) {
5584     jj_la = xla; jj_lastpos = jj_scanpos = token;
5585     boolean retval = !jj_3_3();
5586     jj_save(2, xla);
5587     return retval;
5588   }
5589
5590   static final private boolean jj_2_4(int xla) {
5591     jj_la = xla; jj_lastpos = jj_scanpos = token;
5592     boolean retval = !jj_3_4();
5593     jj_save(3, xla);
5594     return retval;
5595   }
5596
5597   static final private boolean jj_2_5(int xla) {
5598     jj_la = xla; jj_lastpos = jj_scanpos = token;
5599     boolean retval = !jj_3_5();
5600     jj_save(4, xla);
5601     return retval;
5602   }
5603
5604   static final private boolean jj_3R_115() {
5605     if (jj_scan_token(XOR)) return true;
5606     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5607     if (jj_3R_114()) return true;
5608     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5609     return false;
5610   }
5611
5612   static final private boolean jj_3R_210() {
5613     if (jj_3R_116()) return true;
5614     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5615     return false;
5616   }
5617
5618   static final private boolean jj_3R_209() {
5619     if (jj_3R_50()) return true;
5620     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5621     return false;
5622   }
5623
5624   static final private boolean jj_3R_109() {
5625     if (jj_3R_114()) return true;
5626     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5627     Token xsp;
5628     while (true) {
5629       xsp = jj_scanpos;
5630       if (jj_3R_115()) { jj_scanpos = xsp; break; }
5631       if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5632     }
5633     return false;
5634   }
5635
5636   static final private boolean jj_3R_208() {
5637     if (jj_scan_token(IDENTIFIER)) return true;
5638     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5639     return false;
5640   }
5641
5642   static final private boolean jj_3R_203() {
5643     Token xsp;
5644     xsp = jj_scanpos;
5645     if (jj_3R_208()) {
5646     jj_scanpos = xsp;
5647     if (jj_3R_209()) {
5648     jj_scanpos = xsp;
5649     if (jj_3R_210()) return true;
5650     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5651     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5652     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5653     return false;
5654   }
5655
5656   static final private boolean jj_3R_110() {
5657     if (jj_scan_token(BIT_OR)) return true;
5658     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5659     if (jj_3R_109()) return true;
5660     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5661     return false;
5662   }
5663
5664   static final private boolean jj_3R_103() {
5665     if (jj_3R_109()) return true;
5666     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5667     Token xsp;
5668     while (true) {
5669       xsp = jj_scanpos;
5670       if (jj_3R_110()) { jj_scanpos = xsp; break; }
5671       if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5672     }
5673     return false;
5674   }
5675
5676   static final private boolean jj_3R_188() {
5677     if (jj_scan_token(ARRAY)) return true;
5678     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5679     if (jj_3R_198()) return true;
5680     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5681     return false;
5682   }
5683
5684   static final private boolean jj_3R_132() {
5685     if (jj_scan_token(IDENTIFIER)) return true;
5686     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5687     return false;
5688   }
5689
5690   static final private boolean jj_3R_131() {
5691     if (jj_scan_token(LBRACE)) return true;
5692     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5693     if (jj_3R_49()) return true;
5694     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5695     if (jj_scan_token(RBRACE)) return true;
5696     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5697     return false;
5698   }
5699
5700   static final private boolean jj_3R_106() {
5701     if (jj_scan_token(DOT)) return true;
5702     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5703     if (jj_3R_103()) return true;
5704     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5705     return false;
5706   }
5707
5708   static final private boolean jj_3R_122() {
5709     Token xsp;
5710     xsp = jj_scanpos;
5711     if (jj_3R_130()) {
5712     jj_scanpos = xsp;
5713     if (jj_3R_131()) {
5714     jj_scanpos = xsp;
5715     if (jj_3R_132()) return true;
5716     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5717     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5718     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5719     return false;
5720   }
5721
5722   static final private boolean jj_3R_130() {
5723     if (jj_scan_token(DOLLAR)) return true;
5724     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5725     if (jj_3R_122()) return true;
5726     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5727     return false;
5728   }
5729
5730   static final private boolean jj_3R_97() {
5731     if (jj_3R_103()) return true;
5732     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5733     Token xsp;
5734     while (true) {
5735       xsp = jj_scanpos;
5736       if (jj_3R_106()) { jj_scanpos = xsp; break; }
5737       if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5738     }
5739     return false;
5740   }
5741
5742   static final private boolean jj_3R_204() {
5743     if (jj_3R_207()) return true;
5744     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5745     return false;
5746   }
5747
5748   static final private boolean jj_3R_108() {
5749     if (jj_scan_token(_ANDL)) return true;
5750     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5751     return false;
5752   }
5753
5754   static final private boolean jj_3R_107() {
5755     if (jj_scan_token(AND_AND)) return true;
5756     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5757     return false;
5758   }
5759
5760   static final private boolean jj_3R_68() {
5761     if (jj_scan_token(DOLLAR)) return true;
5762     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5763     if (jj_3R_122()) return true;
5764     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5765     return false;
5766   }
5767
5768   static final private boolean jj_3R_100() {
5769     Token xsp;
5770     xsp = jj_scanpos;
5771     if (jj_3R_107()) {
5772     jj_scanpos = xsp;
5773     if (jj_3R_108()) return true;
5774     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5775     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5776     if (jj_3R_97()) return true;
5777     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5778     return false;
5779   }
5780
5781   static final private boolean jj_3R_81() {
5782     if (jj_3R_97()) return true;
5783     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5784     Token xsp;
5785     while (true) {
5786       xsp = jj_scanpos;
5787       if (jj_3R_100()) { jj_scanpos = xsp; break; }
5788       if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5789     }
5790     return false;
5791   }
5792
5793   static final private boolean jj_3R_79() {
5794     if (jj_scan_token(HOOK)) return true;
5795     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5796     if (jj_3R_49()) return true;
5797     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5798     if (jj_scan_token(COLON)) return true;
5799     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5800     if (jj_3R_73()) return true;
5801     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5802     return false;
5803   }
5804
5805   static final private boolean jj_3R_195() {
5806     if (jj_scan_token(NEW)) return true;
5807     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5808     if (jj_3R_203()) return true;
5809     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5810     Token xsp;
5811     xsp = jj_scanpos;
5812     if (jj_3R_204()) jj_scanpos = xsp;
5813     else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5814     return false;
5815   }
5816
5817   static final private boolean jj_3R_202() {
5818     if (jj_3R_207()) return true;
5819     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5820     return false;
5821   }
5822
5823   static final private boolean jj_3R_194() {
5824     if (jj_3R_116()) return true;
5825     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5826     Token xsp;
5827     xsp = jj_scanpos;
5828     if (jj_3R_202()) jj_scanpos = xsp;
5829     else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5830     return false;
5831   }
5832
5833   static final private boolean jj_3R_102() {
5834     if (jj_scan_token(_ORL)) return true;
5835     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5836     return false;
5837   }
5838
5839   static final private boolean jj_3R_101() {
5840     if (jj_scan_token(OR_OR)) return true;
5841     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5842     return false;
5843   }
5844
5845   static final private boolean jj_3R_83() {
5846     Token xsp;
5847     xsp = jj_scanpos;
5848     if (jj_3R_101()) {
5849     jj_scanpos = xsp;
5850     if (jj_3R_102()) return true;
5851     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5852     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5853     if (jj_3R_81()) return true;
5854     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5855     return false;
5856   }
5857
5858   static final private boolean jj_3_1() {
5859     if (jj_3R_40()) return true;
5860     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5861     return false;
5862   }
5863
5864   static final private boolean jj_3R_201() {
5865     if (jj_3R_207()) return true;
5866     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5867     return false;
5868   }
5869
5870   static final private boolean jj_3R_76() {
5871     if (jj_3R_81()) return true;
5872     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5873     Token xsp;
5874     while (true) {
5875       xsp = jj_scanpos;
5876       if (jj_3R_83()) { jj_scanpos = xsp; break; }
5877       if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5878     }
5879     return false;
5880   }
5881
5882   static final private boolean jj_3R_200() {
5883     if (jj_scan_token(STATICCLASSACCESS)) return true;
5884     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5885     if (jj_3R_203()) return true;
5886     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5887     return false;
5888   }
5889
5890   static final private boolean jj_3R_116() {
5891     if (jj_3R_68()) return true;
5892     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5893     Token xsp;
5894     while (true) {
5895       xsp = jj_scanpos;
5896       if (jj_3_1()) { jj_scanpos = xsp; break; }
5897       if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5898     }
5899     return false;
5900   }
5901
5902   static final private boolean jj_3R_51() {
5903     if (jj_scan_token(COMMA)) return true;
5904     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5905     if (jj_3R_49()) return true;
5906     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5907     return false;
5908   }
5909
5910   static final private boolean jj_3R_193() {
5911     if (jj_scan_token(IDENTIFIER)) return true;
5912     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5913     Token xsp;
5914     while (true) {
5915       xsp = jj_scanpos;
5916       if (jj_3R_200()) { jj_scanpos = xsp; break; }
5917       if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5918     }
5919     xsp = jj_scanpos;
5920     if (jj_3R_201()) jj_scanpos = xsp;
5921     else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5922     return false;
5923   }
5924
5925   static final private boolean jj_3R_187() {
5926     Token xsp;
5927     xsp = jj_scanpos;
5928     if (jj_3R_193()) {
5929     jj_scanpos = xsp;
5930     if (jj_3R_194()) {
5931     jj_scanpos = xsp;
5932     if (jj_3R_195()) return true;
5933     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5934     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5935     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5936     return false;
5937   }
5938
5939   static final private boolean jj_3R_73() {
5940     if (jj_3R_76()) return true;
5941     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5942     Token xsp;
5943     xsp = jj_scanpos;
5944     if (jj_3R_79()) jj_scanpos = xsp;
5945     else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5946     return false;
5947   }
5948
5949   static final private boolean jj_3R_45() {
5950     if (jj_3R_49()) return true;
5951     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5952     Token xsp;
5953     while (true) {
5954       xsp = jj_scanpos;
5955       if (jj_3R_51()) { jj_scanpos = xsp; break; }
5956       if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5957     }
5958     return false;
5959   }
5960
5961   static final private boolean jj_3R_178() {
5962     if (jj_3R_188()) return true;
5963     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5964     return false;
5965   }
5966
5967   static final private boolean jj_3R_186() {
5968     if (jj_scan_token(BIT_AND)) return true;
5969     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5970     return false;
5971   }
5972
5973   static final private boolean jj_3R_96() {
5974     if (jj_scan_token(TILDEEQUAL)) return true;
5975     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5976     return false;
5977   }
5978
5979   static final private boolean jj_3R_95() {
5980     if (jj_scan_token(DOTASSIGN)) return true;
5981     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5982     return false;
5983   }
5984
5985   static final private boolean jj_3R_173() {
5986     Token xsp;
5987     xsp = jj_scanpos;
5988     if (jj_3R_177()) {
5989     jj_scanpos = xsp;
5990     if (jj_3R_178()) return true;
5991     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5992     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5993     return false;
5994   }
5995
5996   static final private boolean jj_3R_177() {
5997     Token xsp;
5998     xsp = jj_scanpos;
5999     if (jj_3R_186()) jj_scanpos = xsp;
6000     else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6001     if (jj_3R_187()) return true;
6002     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6003     return false;
6004   }
6005
6006   static final private boolean jj_3R_94() {
6007     if (jj_scan_token(ORASSIGN)) return true;
6008     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6009     return false;
6010   }
6011
6012   static final private boolean jj_3R_93() {
6013     if (jj_scan_token(XORASSIGN)) return true;
6014     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6015     return false;
6016   }
6017
6018   static final private boolean jj_3R_92() {
6019     if (jj_scan_token(ANDASSIGN)) return true;
6020     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6021     return false;
6022   }
6023
6024   static final private boolean jj_3R_91() {
6025     if (jj_scan_token(RSIGNEDSHIFTASSIGN)) return true;
6026     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6027     return false;
6028   }
6029
6030   static final private boolean jj_3R_90() {
6031     if (jj_scan_token(LSHIFTASSIGN)) return true;
6032     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6033     return false;
6034   }
6035
6036   static final private boolean jj_3R_89() {
6037     if (jj_scan_token(MINUSASSIGN)) return true;
6038     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6039     return false;
6040   }
6041
6042   static final private boolean jj_3R_88() {
6043     if (jj_scan_token(PLUSASSIGN)) return true;
6044     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6045     return false;
6046   }
6047
6048   static final private boolean jj_3_5() {
6049     if (jj_3R_45()) return true;
6050     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6051     return false;
6052   }
6053
6054   static final private boolean jj_3R_87() {
6055     if (jj_scan_token(REMASSIGN)) return true;
6056     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6057     return false;
6058   }
6059
6060   static final private boolean jj_3R_86() {
6061     if (jj_scan_token(SLASHASSIGN)) return true;
6062     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6063     return false;
6064   }
6065
6066   static final private boolean jj_3R_85() {
6067     if (jj_scan_token(STARASSIGN)) return true;
6068     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6069     return false;
6070   }
6071
6072   static final private boolean jj_3R_84() {
6073     if (jj_scan_token(ASSIGN)) return true;
6074     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6075     return false;
6076   }
6077
6078   static final private boolean jj_3R_80() {
6079     Token xsp;
6080     xsp = jj_scanpos;
6081     if (jj_3R_84()) {
6082     jj_scanpos = xsp;
6083     if (jj_3R_85()) {
6084     jj_scanpos = xsp;
6085     if (jj_3R_86()) {
6086     jj_scanpos = xsp;
6087     if (jj_3R_87()) {
6088     jj_scanpos = xsp;
6089     if (jj_3R_88()) {
6090     jj_scanpos = xsp;
6091     if (jj_3R_89()) {
6092     jj_scanpos = xsp;
6093     if (jj_3R_90()) {
6094     jj_scanpos = xsp;
6095     if (jj_3R_91()) {
6096     jj_scanpos = xsp;
6097     if (jj_3R_92()) {
6098     jj_scanpos = xsp;
6099     if (jj_3R_93()) {
6100     jj_scanpos = xsp;
6101     if (jj_3R_94()) {
6102     jj_scanpos = xsp;
6103     if (jj_3R_95()) {
6104     jj_scanpos = xsp;
6105     if (jj_3R_96()) return true;
6106     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6107     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6108     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6109     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6110     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6111     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6112     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6113     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6114     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6115     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6116     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6117     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6118     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6119     return false;
6120   }
6121
6122   static final private boolean jj_3R_197() {
6123     if (jj_scan_token(MINUS_MINUS)) return true;
6124     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6125     return false;
6126   }
6127
6128   static final private boolean jj_3R_196() {
6129     if (jj_scan_token(PLUS_PLUS)) return true;
6130     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6131     return false;
6132   }
6133
6134   static final private boolean jj_3R_191() {
6135     Token xsp;
6136     xsp = jj_scanpos;
6137     if (jj_3R_196()) {
6138     jj_scanpos = xsp;
6139     if (jj_3R_197()) return true;
6140     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6141     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6142     return false;
6143   }
6144
6145   static final private boolean jj_3R_175() {
6146     if (jj_3R_173()) return true;
6147     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6148     Token xsp;
6149     xsp = jj_scanpos;
6150     if (jj_3R_191()) jj_scanpos = xsp;
6151     else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6152     return false;
6153   }
6154
6155   static final private boolean jj_3R_99() {
6156     if (jj_3R_105()) return true;
6157     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6158     return false;
6159   }
6160
6161   static final private boolean jj_3R_98() {
6162     if (jj_3R_104()) return true;
6163     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6164     return false;
6165   }
6166
6167   static final private boolean jj_3R_82() {
6168     Token xsp;
6169     xsp = jj_scanpos;
6170     if (jj_3R_98()) {
6171     jj_scanpos = xsp;
6172     if (jj_3R_99()) return true;
6173     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6174     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6175     return false;
6176   }
6177
6178   static final private boolean jj_3R_190() {
6179     if (jj_scan_token(ARRAY)) return true;
6180     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6181     return false;
6182   }
6183
6184   static final private boolean jj_3R_189() {
6185     if (jj_3R_50()) return true;
6186     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6187     return false;
6188   }
6189
6190   static final private boolean jj_3R_78() {
6191     if (jj_3R_82()) return true;
6192     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6193     return false;
6194   }
6195
6196   static final private boolean jj_3R_43() {
6197     if (jj_scan_token(ARRAY)) return true;
6198     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6199     return false;
6200   }
6201
6202   static final private boolean jj_3R_77() {
6203     if (jj_scan_token(BANG)) return true;
6204     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6205     if (jj_3R_74()) return true;
6206     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6207     return false;
6208   }
6209
6210   static final private boolean jj_3R_74() {
6211     Token xsp;
6212     xsp = jj_scanpos;
6213     if (jj_3R_77()) {
6214     jj_scanpos = xsp;
6215     if (jj_3R_78()) return true;
6216     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6217     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6218     return false;
6219   }
6220
6221   static final private boolean jj_3R_174() {
6222     if (jj_scan_token(LPAREN)) return true;
6223     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6224     Token xsp;
6225     xsp = jj_scanpos;
6226     if (jj_3R_189()) {
6227     jj_scanpos = xsp;
6228     if (jj_3R_190()) return true;
6229     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6230     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6231     if (jj_scan_token(RPAREN)) return true;
6232     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6233     if (jj_3R_144()) return true;
6234     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6235     return false;
6236   }
6237
6238   static final private boolean jj_3R_42() {
6239     if (jj_3R_50()) return true;
6240     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6241     return false;
6242   }
6243
6244   static final private boolean jj_3R_58() {
6245     if (jj_3R_74()) return true;
6246     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6247     return false;
6248   }
6249
6250   static final private boolean jj_3_3() {
6251     if (jj_scan_token(LPAREN)) return true;
6252     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6253     Token xsp;
6254     xsp = jj_scanpos;
6255     if (jj_3R_42()) {
6256     jj_scanpos = xsp;
6257     if (jj_3R_43()) return true;
6258     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6259     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6260     if (jj_scan_token(RPAREN)) return true;
6261     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6262     return false;
6263   }
6264
6265   static final private boolean jj_3R_172() {
6266     if (jj_scan_token(LPAREN)) return true;
6267     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6268     if (jj_3R_49()) return true;
6269     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6270     if (jj_scan_token(RPAREN)) return true;
6271     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6272     return false;
6273   }
6274
6275   static final private boolean jj_3R_171() {
6276     if (jj_3R_176()) return true;
6277     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6278     return false;
6279   }
6280
6281   static final private boolean jj_3R_170() {
6282     if (jj_3R_175()) return true;
6283     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6284     return false;
6285   }
6286
6287   static final private boolean jj_3R_166() {
6288     Token xsp;
6289     xsp = jj_scanpos;
6290     if (jj_3R_169()) {
6291     jj_scanpos = xsp;
6292     if (jj_3R_170()) {
6293     jj_scanpos = xsp;
6294     if (jj_3R_171()) {
6295     jj_scanpos = xsp;
6296     if (jj_3R_172()) return true;
6297     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6298     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6299     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6300     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6301     return false;
6302   }
6303
6304   static final private boolean jj_3R_169() {
6305     if (jj_3R_174()) return true;
6306     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6307     return false;
6308   }
6309
6310   static final private boolean jj_3R_168() {
6311     if (jj_scan_token(MINUS_MINUS)) return true;
6312     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6313     return false;
6314   }
6315
6316   static final private boolean jj_3R_167() {
6317     if (jj_scan_token(PLUS_PLUS)) return true;
6318     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6319     return false;
6320   }
6321
6322   static final private boolean jj_3R_75() {
6323     if (jj_3R_80()) return true;
6324     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6325     if (jj_3R_49()) return true;
6326     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6327     return false;
6328   }
6329
6330   static final private boolean jj_3R_44() {
6331     if (jj_3R_49()) return true;
6332     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6333     if (jj_scan_token(SEMICOLON)) return true;
6334     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6335     return false;
6336   }
6337
6338   static final private boolean jj_3R_165() {
6339     Token xsp;
6340     xsp = jj_scanpos;
6341     if (jj_3R_167()) {
6342     jj_scanpos = xsp;
6343     if (jj_3R_168()) return true;
6344     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6345     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6346     if (jj_3R_173()) return true;
6347     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6348     return false;
6349   }
6350
6351   static final private boolean jj_3R_49() {
6352     Token xsp;
6353     xsp = jj_scanpos;
6354     if (jj_3R_57()) {
6355     jj_scanpos = xsp;
6356     if (jj_3R_58()) return true;
6357     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6358     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6359     return false;
6360   }
6361
6362   static final private boolean jj_3R_57() {
6363     if (jj_3R_73()) return true;
6364     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6365     Token xsp;
6366     xsp = jj_scanpos;
6367     if (jj_3R_75()) jj_scanpos = xsp;
6368     else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6369     return false;
6370   }
6371
6372   static final private boolean jj_3R_67() {
6373     if (jj_scan_token(OBJECT)) return true;
6374     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6375     return false;
6376   }
6377
6378   static final private boolean jj_3R_161() {
6379     if (jj_3R_166()) return true;
6380     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6381     return false;
6382   }
6383
6384   static final private boolean jj_3R_66() {
6385     if (jj_scan_token(INTEGER)) return true;
6386     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6387     return false;
6388   }
6389
6390   static final private boolean jj_3R_65() {
6391     if (jj_scan_token(INT)) return true;
6392     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6393     return false;
6394   }
6395
6396   static final private boolean jj_3R_64() {
6397     if (jj_scan_token(FLOAT)) return true;
6398     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6399     return false;
6400   }
6401
6402   static final private boolean jj_3R_160() {
6403     if (jj_3R_165()) return true;
6404     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6405     return false;
6406   }
6407
6408   static final private boolean jj_3R_63() {
6409     if (jj_scan_token(DOUBLE)) return true;
6410     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6411     return false;
6412   }
6413
6414   static final private boolean jj_3R_62() {
6415     if (jj_scan_token(REAL)) return true;
6416     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6417     return false;
6418   }
6419
6420   static final private boolean jj_3R_61() {
6421     if (jj_scan_token(BOOLEAN)) return true;
6422     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6423     return false;
6424   }
6425
6426   static final private boolean jj_3R_60() {
6427     if (jj_scan_token(BOOL)) return true;
6428     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6429     return false;
6430   }
6431
6432   static final private boolean jj_3R_159() {
6433     if (jj_scan_token(MINUS)) return true;
6434     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6435     if (jj_3R_148()) return true;
6436     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6437     return false;
6438   }
6439
6440   static final private boolean jj_3R_50() {
6441     Token xsp;
6442     xsp = jj_scanpos;
6443     if (jj_3R_59()) {
6444     jj_scanpos = xsp;
6445     if (jj_3R_60()) {
6446     jj_scanpos = xsp;
6447     if (jj_3R_61()) {
6448     jj_scanpos = xsp;
6449     if (jj_3R_62()) {
6450     jj_scanpos = xsp;
6451     if (jj_3R_63()) {
6452     jj_scanpos = xsp;
6453     if (jj_3R_64()) {
6454     jj_scanpos = xsp;
6455     if (jj_3R_65()) {
6456     jj_scanpos = xsp;
6457     if (jj_3R_66()) {
6458     jj_scanpos = xsp;
6459     if (jj_3R_67()) return true;
6460     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6461     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6462     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6463     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6464     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6465     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6466     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6467     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6468     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6469     return false;
6470   }
6471
6472   static final private boolean jj_3R_59() {
6473     if (jj_scan_token(STRING)) return true;
6474     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6475     return false;
6476   }
6477
6478   static final private boolean jj_3R_156() {
6479     Token xsp;
6480     xsp = jj_scanpos;
6481     if (jj_3R_158()) {
6482     jj_scanpos = xsp;
6483     if (jj_3R_159()) {
6484     jj_scanpos = xsp;
6485     if (jj_3R_160()) {
6486     jj_scanpos = xsp;
6487     if (jj_3R_161()) return true;
6488     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6489     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6490     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6491     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6492     return false;
6493   }
6494
6495   static final private boolean jj_3R_158() {
6496     if (jj_scan_token(PLUS)) return true;
6497     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6498     if (jj_3R_148()) return true;
6499     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6500     return false;
6501   }
6502
6503   static final private boolean jj_3R_164() {
6504     if (jj_3R_156()) return true;
6505     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6506     return false;
6507   }
6508
6509   static final private boolean jj_3_4() {
6510     if (jj_3R_44()) return true;
6511     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6512     return false;
6513   }
6514
6515   static final private boolean jj_3R_163() {
6516     if (jj_scan_token(BANG)) return true;
6517     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6518     if (jj_3R_157()) return true;
6519     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6520     return false;
6521   }
6522
6523   static final private boolean jj_3R_157() {
6524     Token xsp;
6525     xsp = jj_scanpos;
6526     if (jj_3R_162()) {
6527     jj_scanpos = xsp;
6528     if (jj_3R_163()) {
6529     jj_scanpos = xsp;
6530     if (jj_3R_164()) return true;
6531     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6532     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6533     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6534     return false;
6535   }
6536
6537   static final private boolean jj_3R_162() {
6538     if (jj_scan_token(AT)) return true;
6539     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6540     if (jj_3R_157()) return true;
6541     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6542     return false;
6543   }
6544
6545   static final private boolean jj_3R_155() {
6546     if (jj_3R_156()) return true;
6547     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6548     return false;
6549   }
6550
6551   static final private boolean jj_3R_154() {
6552     if (jj_scan_token(BANG)) return true;
6553     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6554     if (jj_3R_157()) return true;
6555     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6556     return false;
6557   }
6558
6559   static final private boolean jj_3R_216() {
6560     if (jj_scan_token(COMMA)) return true;
6561     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6562     if (jj_3R_49()) return true;
6563     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6564     return false;
6565   }
6566
6567   static final private boolean jj_3R_153() {
6568     if (jj_scan_token(TILDE)) return true;
6569     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6570     if (jj_3R_148()) return true;
6571     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6572     return false;
6573   }
6574
6575   static final private boolean jj_3R_215() {
6576     if (jj_3R_49()) return true;
6577     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6578     Token xsp;
6579     while (true) {
6580       xsp = jj_scanpos;
6581       if (jj_3R_216()) { jj_scanpos = xsp; break; }
6582       if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6583     }
6584     return false;
6585   }
6586
6587   static final private boolean jj_3R_148() {
6588     Token xsp;
6589     xsp = jj_scanpos;
6590     if (jj_3R_152()) {
6591     jj_scanpos = xsp;
6592     if (jj_3R_153()) {
6593     jj_scanpos = xsp;
6594     if (jj_3R_154()) {
6595     jj_scanpos = xsp;
6596     if (jj_3R_155()) return true;
6597     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6598     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6599     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6600     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6601     return false;
6602   }
6603
6604   static final private boolean jj_3R_152() {
6605     if (jj_scan_token(AT)) return true;
6606     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6607     if (jj_3R_148()) return true;
6608     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6609     return false;
6610   }
6611
6612   static final private boolean jj_3R_144() {
6613     if (jj_3R_148()) return true;
6614     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6615     return false;
6616   }
6617
6618   static final private boolean jj_3R_213() {
6619     if (jj_3R_215()) return true;
6620     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6621     return false;
6622   }
6623
6624   static final private boolean jj_3R_151() {
6625     if (jj_scan_token(REMAINDER)) return true;
6626     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6627     return false;
6628   }
6629
6630   static final private boolean jj_3R_150() {
6631     if (jj_scan_token(SLASH)) return true;
6632     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6633     return false;
6634   }
6635
6636   static final private boolean jj_3R_149() {
6637     if (jj_scan_token(STAR)) return true;
6638     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6639     return false;
6640   }
6641
6642   static final private boolean jj_3R_207() {
6643     if (jj_scan_token(LPAREN)) return true;
6644     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6645     Token xsp;
6646     xsp = jj_scanpos;
6647     if (jj_3R_213()) jj_scanpos = xsp;
6648     else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6649     if (jj_scan_token(RPAREN)) return true;
6650     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6651     return false;
6652   }
6653
6654   static final private boolean jj_3R_145() {
6655     Token xsp;
6656     xsp = jj_scanpos;
6657     if (jj_3R_149()) {
6658     jj_scanpos = xsp;
6659     if (jj_3R_150()) {
6660     jj_scanpos = xsp;
6661     if (jj_3R_151()) return true;
6662     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6663     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6664     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6665     if (jj_3R_144()) return true;
6666     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6667     return false;
6668   }
6669
6670   static final private boolean jj_3R_139() {
6671     if (jj_3R_144()) return true;
6672     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6673     Token xsp;
6674     while (true) {
6675       xsp = jj_scanpos;
6676       if (jj_3R_145()) { jj_scanpos = xsp; break; }
6677       if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6678     }
6679     return false;
6680   }
6681
6682   static final private boolean jj_3R_212() {
6683     if (jj_scan_token(LBRACE1)) return true;
6684     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6685     if (jj_scan_token(ID)) return true;
6686     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6687     if (jj_scan_token(RBRACE1)) return true;
6688     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6689     return false;
6690   }
6691
6692   static final private boolean jj_3R_147() {
6693     if (jj_scan_token(MINUS)) return true;
6694     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6695     return false;
6696   }
6697
6698   static final private boolean jj_3R_211() {
6699     if (jj_scan_token(IDENTIFIER)) return true;
6700     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6701     return false;
6702   }
6703
6704   static final private boolean jj_3R_146() {
6705     if (jj_scan_token(PLUS)) return true;
6706     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6707     return false;
6708   }
6709
6710   static final private boolean jj_3R_140() {
6711     Token xsp;
6712     xsp = jj_scanpos;
6713     if (jj_3R_146()) {
6714     jj_scanpos = xsp;
6715     if (jj_3R_147()) return true;
6716     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6717     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6718     if (jj_3R_139()) return true;
6719     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6720     return false;
6721   }
6722
6723   static final private boolean jj_3R_199() {
6724     if (jj_scan_token(DOLLARS)) return true;
6725     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6726     Token xsp;
6727     xsp = jj_scanpos;
6728     if (jj_3R_211()) {
6729     jj_scanpos = xsp;
6730     if (jj_3R_212()) return true;
6731     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6732     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6733     return false;
6734   }
6735
6736   static final private boolean jj_3R_133() {
6737     if (jj_3R_139()) return true;
6738     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6739     Token xsp;
6740     while (true) {
6741       xsp = jj_scanpos;
6742       if (jj_3R_140()) { jj_scanpos = xsp; break; }
6743       if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6744     }
6745     return false;
6746   }
6747
6748   static final private boolean jj_3R_192() {
6749     if (jj_scan_token(DOUBLEQUOTE)) return true;
6750     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6751     Token xsp;
6752     while (true) {
6753       xsp = jj_scanpos;
6754       if (jj_3R_199()) { jj_scanpos = xsp; break; }
6755       if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6756     }
6757     if (jj_scan_token(DOUBLEQUOTE2)) return true;
6758     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6759     return false;
6760   }
6761
6762   static final private boolean jj_3R_143() {
6763     if (jj_scan_token(RUNSIGNEDSHIFT)) return true;
6764     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6765     return false;
6766   }
6767
6768   static final private boolean jj_3R_142() {
6769     if (jj_scan_token(RSIGNEDSHIFT)) return true;
6770     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6771     return false;
6772   }
6773
6774   static final private boolean jj_3R_141() {
6775     if (jj_scan_token(LSHIFT)) return true;
6776     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6777     return false;
6778   }
6779
6780   static final private boolean jj_3R_185() {
6781     if (jj_3R_192()) return true;
6782     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6783     return false;
6784   }
6785
6786   static final private boolean jj_3R_184() {
6787     if (jj_scan_token(NULL)) return true;
6788     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6789     return false;
6790   }
6791
6792   static final private boolean jj_3R_134() {
6793     Token xsp;
6794     xsp = jj_scanpos;
6795     if (jj_3R_141()) {
6796     jj_scanpos = xsp;
6797     if (jj_3R_142()) {
6798     jj_scanpos = xsp;
6799     if (jj_3R_143()) return true;
6800     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6801     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6802     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6803     if (jj_3R_133()) return true;
6804     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6805     return false;
6806   }
6807
6808   static final private boolean jj_3R_113() {
6809     if (jj_scan_token(ASSIGN)) return true;
6810     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6811     if (jj_3R_49()) return true;
6812     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6813     return false;
6814   }
6815
6816   static final private boolean jj_3R_183() {
6817     if (jj_scan_token(FALSE)) return true;
6818     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6819     return false;
6820   }
6821
6822   static final private boolean jj_3R_182() {
6823     if (jj_scan_token(TRUE)) return true;
6824     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6825     return false;
6826   }
6827
6828   static final private boolean jj_3R_123() {
6829     if (jj_3R_133()) return true;
6830     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6831     Token xsp;
6832     while (true) {
6833       xsp = jj_scanpos;
6834       if (jj_3R_134()) { jj_scanpos = xsp; break; }
6835       if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6836     }
6837     return false;
6838   }
6839
6840   static final private boolean jj_3R_181() {
6841     if (jj_scan_token(STRING_LITERAL)) return true;
6842     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6843     return false;
6844   }
6845
6846   static final private boolean jj_3R_180() {
6847     if (jj_scan_token(FLOATING_POINT_LITERAL)) return true;
6848     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6849     return false;
6850   }
6851
6852   static final private boolean jj_3R_179() {
6853     if (jj_scan_token(INTEGER_LITERAL)) return true;
6854     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6855     return false;
6856   }
6857
6858   static final private boolean jj_3R_176() {
6859     Token xsp;
6860     xsp = jj_scanpos;
6861     if (jj_3R_179()) {
6862     jj_scanpos = xsp;
6863     if (jj_3R_180()) {
6864     jj_scanpos = xsp;
6865     if (jj_3R_181()) {
6866     jj_scanpos = xsp;
6867     if (jj_3R_182()) {
6868     jj_scanpos = xsp;
6869     if (jj_3R_183()) {
6870     jj_scanpos = xsp;
6871     if (jj_3R_184()) {
6872     jj_scanpos = xsp;
6873     if (jj_3R_185()) return true;
6874     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6875     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6876     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6877     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6878     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6879     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6880     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6881     return false;
6882   }
6883
6884   static final private boolean jj_3R_117() {
6885     if (jj_3R_116()) return true;
6886     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6887     return false;
6888   }
6889
6890   static final private boolean jj_3R_138() {
6891     if (jj_scan_token(GE)) return true;
6892     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6893     return false;
6894   }
6895
6896   static final private boolean jj_3R_137() {
6897     if (jj_scan_token(LE)) return true;
6898     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6899     return false;
6900   }
6901
6902   static final private boolean jj_3R_136() {
6903     if (jj_scan_token(GT)) return true;
6904     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6905     return false;
6906   }
6907
6908   static final private boolean jj_3R_135() {
6909     if (jj_scan_token(LT)) return true;
6910     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6911     return false;
6912   }
6913
6914   static final private boolean jj_3R_124() {
6915     Token xsp;
6916     xsp = jj_scanpos;
6917     if (jj_3R_135()) {
6918     jj_scanpos = xsp;
6919     if (jj_3R_136()) {
6920     jj_scanpos = xsp;
6921     if (jj_3R_137()) {
6922     jj_scanpos = xsp;
6923     if (jj_3R_138()) return true;
6924     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6925     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6926     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6927     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6928     if (jj_3R_123()) return true;
6929     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6930     return false;
6931   }
6932
6933   static final private boolean jj_3R_120() {
6934     if (jj_3R_123()) return true;
6935     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6936     Token xsp;
6937     while (true) {
6938       xsp = jj_scanpos;
6939       if (jj_3R_124()) { jj_scanpos = xsp; break; }
6940       if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6941     }
6942     return false;
6943   }
6944
6945   static final private boolean jj_3R_72() {
6946     if (jj_3R_50()) return true;
6947     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6948     return false;
6949   }
6950
6951   static final private boolean jj_3R_112() {
6952     if (jj_scan_token(COMMA)) return true;
6953     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6954     Token xsp;
6955     xsp = jj_scanpos;
6956     if (jj_3R_117()) jj_scanpos = xsp;
6957     else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6958     return false;
6959   }
6960
6961   static final private boolean jj_3R_71() {
6962     if (jj_3R_49()) return true;
6963     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6964     return false;
6965   }
6966
6967   static final private boolean jj_3R_56() {
6968     Token xsp;
6969     xsp = jj_scanpos;
6970     if (jj_3R_71()) {
6971     jj_scanpos = xsp;
6972     if (jj_3R_72()) return true;
6973     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6974     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6975     return false;
6976   }
6977
6978   static final private boolean jj_3R_48() {
6979     if (jj_scan_token(LBRACE)) return true;
6980     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6981     Token xsp;
6982     xsp = jj_scanpos;
6983     if (jj_3R_56()) jj_scanpos = xsp;
6984     else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6985     if (jj_scan_token(RBRACE)) return true;
6986     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6987     return false;
6988   }
6989
6990   static final private boolean jj_3R_111() {
6991     if (jj_3R_116()) return true;
6992     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6993     return false;
6994   }
6995
6996   static final private boolean jj_3R_206() {
6997     if (jj_scan_token(COMMA)) return true;
6998     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6999     return false;
7000   }
7001
7002   static final private boolean jj_3_2() {
7003     if (jj_scan_token(COMMA)) return true;
7004     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7005     if (jj_3R_41()) return true;
7006     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7007     return false;
7008   }
7009
7010   static final private boolean jj_3R_70() {
7011     if (jj_3R_50()) return true;
7012     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7013     return false;
7014   }
7015
7016   static final private boolean jj_3R_55() {
7017     Token xsp;
7018     xsp = jj_scanpos;
7019     if (jj_3R_69()) {
7020     jj_scanpos = xsp;
7021     if (jj_3R_70()) return true;
7022     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7023     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7024     return false;
7025   }
7026
7027   static final private boolean jj_3R_69() {
7028     if (jj_3R_49()) return true;
7029     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7030     return false;
7031   }
7032
7033   static final private boolean jj_3R_104() {
7034     if (jj_scan_token(LIST)) return true;
7035     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7036     if (jj_scan_token(LPAREN)) return true;
7037     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7038     Token xsp;
7039     xsp = jj_scanpos;
7040     if (jj_3R_111()) jj_scanpos = xsp;
7041     else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7042     while (true) {
7043       xsp = jj_scanpos;
7044       if (jj_3R_112()) { jj_scanpos = xsp; break; }
7045       if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7046     }
7047     if (jj_scan_token(RPAREN)) return true;
7048     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7049     xsp = jj_scanpos;
7050     if (jj_3R_113()) jj_scanpos = xsp;
7051     else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7052     return false;
7053   }
7054
7055   static final private boolean jj_3R_205() {
7056     if (jj_3R_41()) return true;
7057     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7058     Token xsp;
7059     while (true) {
7060       xsp = jj_scanpos;
7061       if (jj_3_2()) { jj_scanpos = xsp; break; }
7062       if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7063     }
7064     return false;
7065   }
7066
7067   static final private boolean jj_3R_47() {
7068     if (jj_scan_token(LBRACKET)) return true;
7069     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7070     Token xsp;
7071     xsp = jj_scanpos;
7072     if (jj_3R_55()) jj_scanpos = xsp;
7073     else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7074     if (jj_scan_token(RBRACKET)) return true;
7075     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7076     return false;
7077   }
7078
7079   static final private boolean jj_3R_129() {
7080     if (jj_scan_token(TRIPLEEQUAL)) return true;
7081     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7082     return false;
7083   }
7084
7085   static final private boolean jj_3R_128() {
7086     if (jj_scan_token(BANGDOUBLEEQUAL)) return true;
7087     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7088     return false;
7089   }
7090
7091   static final private boolean jj_3R_127() {
7092     if (jj_scan_token(NOT_EQUAL)) return true;
7093     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7094     return false;
7095   }
7096
7097   static final private boolean jj_3R_198() {
7098     if (jj_scan_token(LPAREN)) return true;
7099     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7100     Token xsp;
7101     xsp = jj_scanpos;
7102     if (jj_3R_205()) jj_scanpos = xsp;
7103     else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7104     xsp = jj_scanpos;
7105     if (jj_3R_206()) jj_scanpos = xsp;
7106     else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7107     if (jj_scan_token(RPAREN)) return true;
7108     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7109     return false;
7110   }
7111
7112   static final private boolean jj_3R_126() {
7113     if (jj_scan_token(DIF)) return true;
7114     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7115     return false;
7116   }
7117
7118   static final private boolean jj_3R_125() {
7119     if (jj_scan_token(EQUAL_EQUAL)) return true;
7120     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7121     return false;
7122   }
7123
7124   static final private boolean jj_3R_54() {
7125     if (jj_3R_68()) return true;
7126     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7127     return false;
7128   }
7129
7130   static final private boolean jj_3R_121() {
7131     Token xsp;
7132     xsp = jj_scanpos;
7133     if (jj_3R_125()) {
7134     jj_scanpos = xsp;
7135     if (jj_3R_126()) {
7136     jj_scanpos = xsp;
7137     if (jj_3R_127()) {
7138     jj_scanpos = xsp;
7139     if (jj_3R_128()) {
7140     jj_scanpos = xsp;
7141     if (jj_3R_129()) return true;
7142     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7143     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7144     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7145     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7146     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7147     if (jj_3R_120()) return true;
7148     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7149     return false;
7150   }
7151
7152   static final private boolean jj_3R_53() {
7153     if (jj_scan_token(IDENTIFIER)) return true;
7154     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7155     return false;
7156   }
7157
7158   static final private boolean jj_3R_118() {
7159     if (jj_3R_120()) return true;
7160     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7161     Token xsp;
7162     while (true) {
7163       xsp = jj_scanpos;
7164       if (jj_3R_121()) { jj_scanpos = xsp; break; }
7165       if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7166     }
7167     return false;
7168   }
7169
7170   static final private boolean jj_3R_105() {
7171     if (jj_scan_token(PRINT)) return true;
7172     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7173     if (jj_3R_49()) return true;
7174     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7175     return false;
7176   }
7177
7178   static final private boolean jj_3R_214() {
7179     if (jj_scan_token(ARRAYASSIGN)) return true;
7180     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7181     if (jj_3R_49()) return true;
7182     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7183     return false;
7184   }
7185
7186   static final private boolean jj_3R_41() {
7187     if (jj_3R_49()) return true;
7188     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7189     Token xsp;
7190     xsp = jj_scanpos;
7191     if (jj_3R_214()) jj_scanpos = xsp;
7192     else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7193     return false;
7194   }
7195
7196   static final private boolean jj_3R_52() {
7197     if (jj_scan_token(LBRACE)) return true;
7198     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7199     if (jj_3R_49()) return true;
7200     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7201     if (jj_scan_token(RBRACE)) return true;
7202     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7203     return false;
7204   }
7205
7206   static final private boolean jj_3R_119() {
7207     if (jj_scan_token(BIT_AND)) return true;
7208     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7209     if (jj_3R_118()) return true;
7210     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7211     return false;
7212   }
7213
7214   static final private boolean jj_3R_46() {
7215     if (jj_scan_token(CLASSACCESS)) return true;
7216     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7217     Token xsp;
7218     xsp = jj_scanpos;
7219     if (jj_3R_52()) {
7220     jj_scanpos = xsp;
7221     if (jj_3R_53()) {
7222     jj_scanpos = xsp;
7223     if (jj_3R_54()) return true;
7224     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7225     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7226     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7227     return false;
7228   }
7229
7230   static final private boolean jj_3R_40() {
7231     Token xsp;
7232     xsp = jj_scanpos;
7233     if (jj_3R_46()) {
7234     jj_scanpos = xsp;
7235     if (jj_3R_47()) {
7236     jj_scanpos = xsp;
7237     if (jj_3R_48()) return true;
7238     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7239     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7240     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7241     return false;
7242   }
7243
7244   static final private boolean jj_3R_114() {
7245     if (jj_3R_118()) return true;
7246     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7247     Token xsp;
7248     while (true) {
7249       xsp = jj_scanpos;
7250       if (jj_3R_119()) { jj_scanpos = xsp; break; }
7251       if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7252     }
7253     return false;
7254   }
7255
7256   static private boolean jj_initialized_once = false;
7257   static public PHPParserTokenManager token_source;
7258   static SimpleCharStream jj_input_stream;
7259   static public Token token, jj_nt;
7260   static private int jj_ntk;
7261   static private Token jj_scanpos, jj_lastpos;
7262   static private int jj_la;
7263   static public boolean lookingAhead = false;
7264   static private boolean jj_semLA;
7265   static private int jj_gen;
7266   static final private int[] jj_la1 = new int[128];
7267   static private int[] jj_la1_0;
7268   static private int[] jj_la1_1;
7269   static private int[] jj_la1_2;
7270   static private int[] jj_la1_3;
7271   static private int[] jj_la1_4;
7272   static {
7273       jj_la1_0();
7274       jj_la1_1();
7275       jj_la1_2();
7276       jj_la1_3();
7277       jj_la1_4();
7278    }
7279    private static void jj_la1_0() {
7280       jj_la1_0 = new int[] {0x5800001e,0x6,0x6,0x5800001e,0x0,0x58000000,0x0,0x30000000,0x30000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x40000000,0x40000000,0x8,0x6,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x58000010,0x58000010,0x58000000,0x58000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x58000010,0x58000010,0x0,0x0,0x40000010,0x40000010,0x80000000,0x0,0x40000010,0x80000000,0x0,0x40000010,0x40000010,0x40000010,0x40000010,0x40000010,0x40000000,0x40000000,0x0,0x0,0x0,0x40000000,0x40000000,0x0,0x0,0x0,0x0,};
7281    }
7282    private static void jj_la1_1() {
7283       jj_la1_1 = new int[] {0xd7541ffe,0x0,0x0,0xd7541ffe,0x0,0xd7541ffe,0x200000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xc2000002,0x8000,0xc300001a,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xc300001a,0x18,0x18,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xc3000002,0xc3000002,0xc3000002,0x0,0xc3000002,0x2,0x0,0x0,0x0,0x1000002,0x4000,0x0,0x0,0x0,0x1000000,0x0,0x0,0xc300001a,0xc300001a,0xc300001a,0xc300001a,0x2000,0xc2000000,0x0,0x0,0xc300001a,0x0,0x0,0x14541fe0,0xd7541ffe,0x0,0x0,0x3c0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xd7541ffe,0xd7541ffe,0xd7541ffe,0xd7541ffa,0x0,0x0,0x0,0x0,0x1000002,0x0,0x90000,0x90000,0xd7541ffe,0xd7541ffe,0x90000,0xc300001a,0xd7541ffe,0xd7541ffe,0x0,0x1,0xd7541ffe,0x0,0x1,0xd7541ffe,0xd7541ffe,0xd7541ffe,0xd7541ffe,0xd7541ffe,0xd7541ffe,0xd7541ffe,0xc300001a,0xc300001a,0xc300001a,0xd7541ffe,0xd7541ffe,0xc300001a,0x0,0xc300001a,0xc300001a,};
7284    }
7285    private static void jj_la1_2() {
7286       jj_la1_2 = new int[] {0x27870021,0x0,0x0,0x27870021,0x0,0x27870021,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x6000000,0x0,0x27870000,0x0,0x20000000,0x0,0x20000000,0x20000000,0xff80,0x0,0x27870000,0x20000,0x0,0x0,0x80000,0x200000,0x200000,0x400000,0x400000,0x0,0x40000000,0x80000000,0x20000000,0x0,0x0,0x0,0x0,0x0,0x0,0x6000000,0x6000000,0x18000000,0x18000000,0x27870000,0x27830000,0x27800000,0x1800000,0x20000000,0xff80,0x1800000,0x1800000,0x20000000,0x20000000,0x0,0x0,0x0,0x0,0x0,0xff80,0x0,0x2787ff80,0x2787ff80,0x2787ff80,0x2787ff80,0x0,0x0,0x0,0x0,0x27870000,0x0,0x10000,0x10021,0x27870021,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x27870021,0x27870021,0x27870021,0x27870021,0x0,0x0,0x1800000,0x1800000,0x21800000,0x100000,0x0,0x0,0x27870021,0x27870021,0x0,0x27870000,0x27870021,0x27870021,0x0,0x0,0x27870021,0x0,0x0,0x27970021,0x27870021,0x27870021,0x27870021,0x27870021,0x27870021,0x27970021,0x27870000,0x27870000,0x27870000,0x27870021,0x27970021,0x27870000,0x0,0x27870000,0x27870000,};
7287    }
7288    private static void jj_la1_3() {
7289       jj_la1_3 = new int[] {0x18011440,0x0,0x0,0x18011440,0x0,0x18011440,0x0,0x0,0x0,0x0,0x10000000,0x0,0x0,0x18000000,0x440,0x440,0x10011440,0x0,0x18011440,0x0,0x0,0x0,0x8000000,0x0,0x0,0x0,0x18011440,0x0,0x0,0x0,0x0,0x10,0x10,0x20,0x20,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xe,0xe,0x0,0x0,0x1,0x1,0x18011440,0x18011440,0x18011440,0x0,0x18011440,0x0,0x0,0x0,0x0,0x18000000,0x0,0x0,0x0,0x0,0x18000000,0x18000000,0x18000000,0x18011440,0x18011440,0x18011440,0x18011440,0x0,0x11440,0x20000,0x10080000,0x18011440,0x0,0x0,0x10000000,0x18011440,0x0,0x0,0x0,0x8000000,0x0,0x8000000,0x0,0x0,0x0,0x0,0x18011440,0x18011440,0x18011440,0x18011440,0x0,0x0,0x0,0x0,0x18000000,0x0,0x0,0x0,0x18011440,0x18011440,0x0,0x18011440,0x18011440,0x18011440,0x0,0x0,0x18011440,0x0,0x0,0x18011440,0x18011440,0x18011440,0x18011440,0x18011440,0x18011440,0x18011440,0x18011440,0x18011440,0x18011440,0x18011440,0x18011440,0x18011440,0x0,0x18011440,0x18011440,};
7290    }
7291    private static void jj_la1_4() {
7292       jj_la1_4 = new int[] {0x8a,0x0,0x0,0x8a,0x80,0x8a,0x0,0x0,0x0,0x100,0x8,0x80000,0x80000,0x8,0x0,0x0,0x0,0x0,0x2,0x100,0x0,0x100,0x0,0x0,0x0,0xfff80000,0x2,0x0,0x0,0xfff80000,0x0,0x0,0x0,0x0,0x0,0x200,0x0,0x0,0x0,0x79000,0x79000,0x6c00,0x6c00,0x0,0x0,0x0,0x0,0x0,0x0,0x2,0x2,0x2,0x0,0x2,0x0,0x0,0x0,0x0,0x0,0x0,0x2,0x2,0x2,0x0,0x0,0x8,0x2,0x2,0x2,0x2,0x28,0x0,0x0,0x0,0x2,0x100,0x0,0x88,0x8a,0x0,0x0,0x0,0x0,0x100,0x0,0x80000,0x100,0x100,0x100,0x8a,0x8a,0x8a,0x8a,0x100,0x80000,0x0,0x0,0x0,0x8,0x0,0x0,0x8a,0x8a,0x0,0x2,0x8a,0x8a,0x0,0x0,0x8a,0x0,0x0,0x8a,0x8a,0x8a,0x8a,0x8a,0x8a,0x8a,0x2,0x2,0x2,0x8a,0x8a,0x2,0x100,0x2,0x2,};
7293    }
7294   static final private JJCalls[] jj_2_rtns = new JJCalls[5];
7295   static private boolean jj_rescan = false;
7296   static private int jj_gc = 0;
7297
7298   public PHPParser(java.io.InputStream stream) {
7299     if (jj_initialized_once) {
7300       System.out.println("ERROR: Second call to constructor of static parser.  You must");
7301       System.out.println("       either use ReInit() or set the JavaCC option STATIC to false");
7302       System.out.println("       during parser generation.");
7303       throw new Error();
7304     }
7305     jj_initialized_once = true;
7306     jj_input_stream = new SimpleCharStream(stream, 1, 1);
7307     token_source = new PHPParserTokenManager(jj_input_stream);
7308     token = new Token();
7309     jj_ntk = -1;
7310     jj_gen = 0;
7311     for (int i = 0; i < 128; i++) jj_la1[i] = -1;
7312     for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
7313   }
7314
7315   static public void ReInit(java.io.InputStream stream) {
7316     jj_input_stream.ReInit(stream, 1, 1);
7317     token_source.ReInit(jj_input_stream);
7318     token = new Token();
7319     jj_ntk = -1;
7320     jj_gen = 0;
7321     for (int i = 0; i < 128; i++) jj_la1[i] = -1;
7322     for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
7323   }
7324
7325   public PHPParser(java.io.Reader stream) {
7326     if (jj_initialized_once) {
7327       System.out.println("ERROR: Second call to constructor of static parser.  You must");
7328       System.out.println("       either use ReInit() or set the JavaCC option STATIC to false");
7329       System.out.println("       during parser generation.");
7330       throw new Error();
7331     }
7332     jj_initialized_once = true;
7333     jj_input_stream = new SimpleCharStream(stream, 1, 1);
7334     token_source = new PHPParserTokenManager(jj_input_stream);
7335     token = new Token();
7336     jj_ntk = -1;
7337     jj_gen = 0;
7338     for (int i = 0; i < 128; i++) jj_la1[i] = -1;
7339     for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
7340   }
7341
7342   static public void ReInit(java.io.Reader stream) {
7343     jj_input_stream.ReInit(stream, 1, 1);
7344     token_source.ReInit(jj_input_stream);
7345     token = new Token();
7346     jj_ntk = -1;
7347     jj_gen = 0;
7348     for (int i = 0; i < 128; i++) jj_la1[i] = -1;
7349     for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
7350   }
7351
7352   public PHPParser(PHPParserTokenManager tm) {
7353     if (jj_initialized_once) {
7354       System.out.println("ERROR: Second call to constructor of static parser.  You must");
7355       System.out.println("       either use ReInit() or set the JavaCC option STATIC to false");
7356       System.out.println("       during parser generation.");
7357       throw new Error();
7358     }
7359     jj_initialized_once = true;
7360     token_source = tm;
7361     token = new Token();
7362     jj_ntk = -1;
7363     jj_gen = 0;
7364     for (int i = 0; i < 128; i++) jj_la1[i] = -1;
7365     for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
7366   }
7367
7368   public void ReInit(PHPParserTokenManager tm) {
7369     token_source = tm;
7370     token = new Token();
7371     jj_ntk = -1;
7372     jj_gen = 0;
7373     for (int i = 0; i < 128; i++) jj_la1[i] = -1;
7374     for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
7375   }
7376
7377   static final private Token jj_consume_token(int kind) throws ParseException {
7378     Token oldToken;
7379     if ((oldToken = token).next != null) token = token.next;
7380     else token = token.next = token_source.getNextToken();
7381     jj_ntk = -1;
7382     if (token.kind == kind) {
7383       jj_gen++;
7384       if (++jj_gc > 100) {
7385         jj_gc = 0;
7386         for (int i = 0; i < jj_2_rtns.length; i++) {
7387           JJCalls c = jj_2_rtns[i];
7388           while (c != null) {
7389             if (c.gen < jj_gen) c.first = null;
7390             c = c.next;
7391           }
7392         }
7393       }
7394       return token;
7395     }
7396     token = oldToken;
7397     jj_kind = kind;
7398     throw generateParseException();
7399   }
7400
7401   static final private boolean jj_scan_token(int kind) {
7402     if (jj_scanpos == jj_lastpos) {
7403       jj_la--;
7404       if (jj_scanpos.next == null) {
7405         jj_lastpos = jj_scanpos = jj_scanpos.next = token_source.getNextToken();
7406       } else {
7407         jj_lastpos = jj_scanpos = jj_scanpos.next;
7408       }
7409     } else {
7410       jj_scanpos = jj_scanpos.next;
7411     }
7412     if (jj_rescan) {
7413       int i = 0; Token tok = token;
7414       while (tok != null && tok != jj_scanpos) { i++; tok = tok.next; }
7415       if (tok != null) jj_add_error_token(kind, i);
7416     }
7417     return (jj_scanpos.kind != kind);
7418   }
7419
7420   static final public Token getNextToken() {
7421     if (token.next != null) token = token.next;
7422     else token = token.next = token_source.getNextToken();
7423     jj_ntk = -1;
7424     jj_gen++;
7425     return token;
7426   }
7427
7428   static final public Token getToken(int index) {
7429     Token t = lookingAhead ? jj_scanpos : token;
7430     for (int i = 0; i < index; i++) {
7431       if (t.next != null) t = t.next;
7432       else t = t.next = token_source.getNextToken();
7433     }
7434     return t;
7435   }
7436
7437   static final private int jj_ntk() {
7438     if ((jj_nt=token.next) == null)
7439       return (jj_ntk = (token.next=token_source.getNextToken()).kind);
7440     else
7441       return (jj_ntk = jj_nt.kind);
7442   }
7443
7444   static private java.util.Vector jj_expentries = new java.util.Vector();
7445   static private int[] jj_expentry;
7446   static private int jj_kind = -1;
7447   static private int[] jj_lasttokens = new int[100];
7448   static private int jj_endpos;
7449
7450   static private void jj_add_error_token(int kind, int pos) {
7451     if (pos >= 100) return;
7452     if (pos == jj_endpos + 1) {
7453       jj_lasttokens[jj_endpos++] = kind;
7454     } else if (jj_endpos != 0) {
7455       jj_expentry = new int[jj_endpos];
7456       for (int i = 0; i < jj_endpos; i++) {
7457         jj_expentry[i] = jj_lasttokens[i];
7458       }
7459       boolean exists = false;
7460       for (java.util.Enumeration enum = jj_expentries.elements(); enum.hasMoreElements();) {
7461         int[] oldentry = (int[])(enum.nextElement());
7462         if (oldentry.length == jj_expentry.length) {
7463           exists = true;
7464           for (int i = 0; i < jj_expentry.length; i++) {
7465             if (oldentry[i] != jj_expentry[i]) {
7466               exists = false;
7467               break;
7468             }
7469           }
7470           if (exists) break;
7471         }
7472       }
7473       if (!exists) jj_expentries.addElement(jj_expentry);
7474       if (pos != 0) jj_lasttokens[(jj_endpos = pos) - 1] = kind;
7475     }
7476   }
7477
7478   static public ParseException generateParseException() {
7479     jj_expentries.removeAllElements();
7480     boolean[] la1tokens = new boolean[160];
7481     for (int i = 0; i < 160; i++) {
7482       la1tokens[i] = false;
7483     }
7484     if (jj_kind >= 0) {
7485       la1tokens[jj_kind] = true;
7486       jj_kind = -1;
7487     }
7488     for (int i = 0; i < 128; i++) {
7489       if (jj_la1[i] == jj_gen) {
7490         for (int j = 0; j < 32; j++) {
7491           if ((jj_la1_0[i] & (1<<j)) != 0) {
7492             la1tokens[j] = true;
7493           }
7494           if ((jj_la1_1[i] & (1<<j)) != 0) {
7495             la1tokens[32+j] = true;
7496           }
7497           if ((jj_la1_2[i] & (1<<j)) != 0) {
7498             la1tokens[64+j] = true;
7499           }
7500           if ((jj_la1_3[i] & (1<<j)) != 0) {
7501             la1tokens[96+j] = true;
7502           }
7503           if ((jj_la1_4[i] & (1<<j)) != 0) {
7504             la1tokens[128+j] = true;
7505           }
7506         }
7507       }
7508     }
7509     for (int i = 0; i < 160; i++) {
7510       if (la1tokens[i]) {
7511         jj_expentry = new int[1];
7512         jj_expentry[0] = i;
7513         jj_expentries.addElement(jj_expentry);
7514       }
7515     }
7516     jj_endpos = 0;
7517     jj_rescan_token();
7518     jj_add_error_token(0, 0);
7519     int[][] exptokseq = new int[jj_expentries.size()][];
7520     for (int i = 0; i < jj_expentries.size(); i++) {
7521       exptokseq[i] = (int[])jj_expentries.elementAt(i);
7522     }
7523     return new ParseException(token, exptokseq, tokenImage);
7524   }
7525
7526   static final public void enable_tracing() {
7527   }
7528
7529   static final public void disable_tracing() {
7530   }
7531
7532   static final private void jj_rescan_token() {
7533     jj_rescan = true;
7534     for (int i = 0; i < 5; i++) {
7535       JJCalls p = jj_2_rtns[i];
7536       do {
7537         if (p.gen > jj_gen) {
7538           jj_la = p.arg; jj_lastpos = jj_scanpos = p.first;
7539           switch (i) {
7540             case 0: jj_3_1(); break;
7541             case 1: jj_3_2(); break;
7542             case 2: jj_3_3(); break;
7543             case 3: jj_3_4(); break;
7544             case 4: jj_3_5(); break;
7545           }
7546         }
7547         p = p.next;
7548       } while (p != null);
7549     }
7550     jj_rescan = false;
7551   }
7552
7553   static final private void jj_save(int index, int xla) {
7554     JJCalls p = jj_2_rtns[index];
7555     while (p.gen > jj_gen) {
7556       if (p.next == null) { p = p.next = new JJCalls(); break; }
7557       p = p.next;
7558     }
7559     p.gen = jj_gen + xla - jj_la; p.first = token; p.arg = xla;
7560   }
7561
7562   static final class JJCalls {
7563     int gen;
7564     Token first;
7565     int arg;
7566     JJCalls next;
7567   }
7568
7569 }