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