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     expr = SwitchLabel();
4009     label_31:
4010     while (true) {
4011       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
4012       case PHPEND:
4013       case CLASS:
4014       case FUNCTION:
4015       case IF:
4016       case ARRAY:
4017       case BREAK:
4018       case LIST:
4019       case PRINT:
4020       case ECHO:
4021       case INCLUDE:
4022       case REQUIRE:
4023       case INCLUDE_ONCE:
4024       case REQUIRE_ONCE:
4025       case GLOBAL:
4026       case DEFINE:
4027       case STATIC:
4028       case CONTINUE:
4029       case DO:
4030       case FOR:
4031       case NEW:
4032       case NULL:
4033       case RETURN:
4034       case SWITCH:
4035       case TRUE:
4036       case FALSE:
4037       case WHILE:
4038       case FOREACH:
4039       case AT:
4040       case BANG:
4041       case TILDE:
4042       case PLUS_PLUS:
4043       case MINUS_MINUS:
4044       case PLUS:
4045       case MINUS:
4046       case BIT_AND:
4047       case INTEGER_LITERAL:
4048       case FLOATING_POINT_LITERAL:
4049       case STRING_LITERAL:
4050       case DOUBLEQUOTE:
4051       case DOLLAR:
4052       case IDENTIFIER:
4053       case LPAREN:
4054       case LBRACE:
4055       case SEMICOLON:
4056         ;
4057         break;
4058       default:
4059         jj_la1[101] = jj_gen;
4060         break label_31;
4061       }
4062       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
4063       case CLASS:
4064       case FUNCTION:
4065       case IF:
4066       case ARRAY:
4067       case LIST:
4068       case PRINT:
4069       case ECHO:
4070       case INCLUDE:
4071       case REQUIRE:
4072       case INCLUDE_ONCE:
4073       case REQUIRE_ONCE:
4074       case GLOBAL:
4075       case DEFINE:
4076       case STATIC:
4077       case CONTINUE:
4078       case DO:
4079       case FOR:
4080       case NEW:
4081       case NULL:
4082       case RETURN:
4083       case SWITCH:
4084       case TRUE:
4085       case FALSE:
4086       case WHILE:
4087       case FOREACH:
4088       case AT:
4089       case BANG:
4090       case TILDE:
4091       case PLUS_PLUS:
4092       case MINUS_MINUS:
4093       case PLUS:
4094       case MINUS:
4095       case BIT_AND:
4096       case INTEGER_LITERAL:
4097       case FLOATING_POINT_LITERAL:
4098       case STRING_LITERAL:
4099       case DOUBLEQUOTE:
4100       case DOLLAR:
4101       case IDENTIFIER:
4102       case LPAREN:
4103       case LBRACE:
4104       case SEMICOLON:
4105         statement = BlockStatementNoBreak();
4106                                          stmts.add(statement);
4107         break;
4108       case PHPEND:
4109         statement = htmlBlock();
4110                                          if (statement != null) {stmts.add(statement);}
4111         break;
4112       case BREAK:
4113         statement = BreakStatement();
4114                                          stmts.add(statement);
4115         break;
4116       default:
4117         jj_la1[102] = jj_gen;
4118         jj_consume_token(-1);
4119         throw new ParseException();
4120       }
4121     }
4122     final int listSize = stmts.size();
4123     final Statement[] stmtsArray = new Statement[listSize];
4124     stmts.toArray(stmtsArray);
4125     if (expr == null) {//it's a default
4126       {if (true) return new DefaultCase(stmtsArray,token.sourceStart,stmtsArray[listSize-1].sourceEnd);}
4127     }
4128     if (listSize != 0) {
4129       {if (true) return new Case(expr,stmtsArray,expr.sourceStart,stmtsArray[listSize-1].sourceEnd);}
4130     } else {
4131       {if (true) return new Case(expr,stmtsArray,expr.sourceStart,expr.sourceEnd);}
4132     }
4133     throw new Error("Missing return statement in function");
4134   }
4135
4136 /**
4137  * A SwitchLabel.
4138  * case Expression() :
4139  * default :
4140  * @return the if it was a case and null if not
4141  */
4142   static final public Expression SwitchLabel() throws ParseException {
4143   final Expression expr;
4144     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
4145     case CASE:
4146       token = jj_consume_token(CASE);
4147       try {
4148         expr = Expression();
4149       } catch (ParseException e) {
4150     if (errorMessage != null) {if (true) throw e;}
4151     errorMessage = "expression expected after 'case' keyword";
4152     errorLevel   = ERROR;
4153     errorStart = token.sourceEnd +1;
4154     errorEnd   = token.sourceEnd +1;
4155     {if (true) throw e;}
4156       }
4157       try {
4158         token = jj_consume_token(COLON);
4159       } catch (ParseException e) {
4160     errorMessage = "':' expected after case expression";
4161     errorLevel   = ERROR;
4162     errorStart = expr.sourceEnd+1;
4163     errorEnd   = expr.sourceEnd+1;
4164     processParseExceptionDebug(e);
4165       }
4166    {if (true) return expr;}
4167       break;
4168     case _DEFAULT:
4169       token = jj_consume_token(_DEFAULT);
4170       try {
4171         jj_consume_token(COLON);
4172       } catch (ParseException e) {
4173     errorMessage = "':' expected after 'default' keyword";
4174     errorLevel   = ERROR;
4175     errorStart = token.sourceEnd+1;
4176     errorEnd   = token.sourceEnd+1;
4177     processParseExceptionDebug(e);
4178       }
4179    {if (true) return null;}
4180       break;
4181     default:
4182       jj_la1[103] = jj_gen;
4183       jj_consume_token(-1);
4184       throw new ParseException();
4185     }
4186     throw new Error("Missing return statement in function");
4187   }
4188
4189   static final public Break BreakStatement() throws ParseException {
4190   Expression expression = null;
4191   final Token token, token2;
4192   int pos;
4193     token = jj_consume_token(BREAK);
4194                    pos = token.sourceEnd+1;
4195     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
4196     case ARRAY:
4197     case LIST:
4198     case PRINT:
4199     case NEW:
4200     case NULL:
4201     case TRUE:
4202     case FALSE:
4203     case AT:
4204     case BANG:
4205     case TILDE:
4206     case PLUS_PLUS:
4207     case MINUS_MINUS:
4208     case PLUS:
4209     case MINUS:
4210     case BIT_AND:
4211     case INTEGER_LITERAL:
4212     case FLOATING_POINT_LITERAL:
4213     case STRING_LITERAL:
4214     case DOUBLEQUOTE:
4215     case DOLLAR:
4216     case IDENTIFIER:
4217     case LPAREN:
4218       expression = Expression();
4219                                pos = expression.sourceEnd+1;
4220       break;
4221     default:
4222       jj_la1[104] = jj_gen;
4223       ;
4224     }
4225     try {
4226       token2 = jj_consume_token(SEMICOLON);
4227      pos = token2.sourceEnd;
4228     } catch (ParseException e) {
4229     errorMessage = "';' expected after 'break' keyword";
4230     errorLevel   = ERROR;
4231     errorStart = pos;
4232     errorEnd   = pos;
4233     processParseExceptionDebug(e);
4234     }
4235    {if (true) return new Break(expression, token.sourceStart, pos);}
4236     throw new Error("Missing return statement in function");
4237   }
4238
4239   static final public IfStatement IfStatement() throws ParseException {
4240   final Expression condition;
4241   final IfStatement ifStatement;
4242   Token token;
4243     token = jj_consume_token(IF);
4244     condition = Condition("if");
4245     ifStatement = IfStatement0(condition,token.sourceStart,token.sourceEnd);
4246    {if (true) return ifStatement;}
4247     throw new Error("Missing return statement in function");
4248   }
4249
4250   static final public Expression Condition(final String keyword) throws ParseException {
4251   final Expression condition;
4252     try {
4253       jj_consume_token(LPAREN);
4254     } catch (ParseException e) {
4255     errorMessage = "'(' expected after " + keyword + " keyword";
4256     errorLevel   = ERROR;
4257     errorStart = PHPParser.token.sourceEnd + 1;
4258     errorEnd   = PHPParser.token.sourceEnd + 1;
4259     processParseExceptionDebug(e);
4260     }
4261     condition = Expression();
4262     try {
4263       jj_consume_token(RPAREN);
4264     } catch (ParseException e) {
4265     errorMessage = "')' expected after " + keyword + " keyword";
4266     errorLevel   = ERROR;
4267     errorStart = condition.sourceEnd+1;
4268     errorEnd   = condition.sourceEnd+1;
4269     processParseExceptionDebug(e);
4270     }
4271    {if (true) return condition;}
4272     throw new Error("Missing return statement in function");
4273   }
4274
4275   static final public IfStatement IfStatement0(final Expression condition, final int start,final int end) throws ParseException {
4276   Statement statement;
4277   final Statement stmt;
4278   final Statement[] statementsArray;
4279   ElseIf elseifStatement;
4280   Else elseStatement = null;
4281   final ArrayList stmts;
4282   final ArrayList elseIfList = new ArrayList();
4283   final ElseIf[] elseIfs;
4284   int pos = SimpleCharStream.getPosition();
4285   final int endStatements;
4286     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
4287     case COLON:
4288       jj_consume_token(COLON);
4289    stmts = new ArrayList();
4290       label_32:
4291       while (true) {
4292         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
4293         case PHPEND:
4294         case IF:
4295         case ARRAY:
4296         case BREAK:
4297         case LIST:
4298         case PRINT:
4299         case ECHO:
4300         case INCLUDE:
4301         case REQUIRE:
4302         case INCLUDE_ONCE:
4303         case REQUIRE_ONCE:
4304         case GLOBAL:
4305         case DEFINE:
4306         case STATIC:
4307         case CONTINUE:
4308         case DO:
4309         case FOR:
4310         case NEW:
4311         case NULL:
4312         case RETURN:
4313         case SWITCH:
4314         case TRUE:
4315         case FALSE:
4316         case WHILE:
4317         case FOREACH:
4318         case AT:
4319         case BANG:
4320         case TILDE:
4321         case PLUS_PLUS:
4322         case MINUS_MINUS:
4323         case PLUS:
4324         case MINUS:
4325         case BIT_AND:
4326         case INTEGER_LITERAL:
4327         case FLOATING_POINT_LITERAL:
4328         case STRING_LITERAL:
4329         case DOUBLEQUOTE:
4330         case DOLLAR:
4331         case IDENTIFIER:
4332         case LPAREN:
4333         case LBRACE:
4334         case SEMICOLON:
4335           ;
4336           break;
4337         default:
4338           jj_la1[105] = jj_gen;
4339           break label_32;
4340         }
4341         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
4342         case IF:
4343         case ARRAY:
4344         case BREAK:
4345         case LIST:
4346         case PRINT:
4347         case ECHO:
4348         case INCLUDE:
4349         case REQUIRE:
4350         case INCLUDE_ONCE:
4351         case REQUIRE_ONCE:
4352         case GLOBAL:
4353         case DEFINE:
4354         case STATIC:
4355         case CONTINUE:
4356         case DO:
4357         case FOR:
4358         case NEW:
4359         case NULL:
4360         case RETURN:
4361         case SWITCH:
4362         case TRUE:
4363         case FALSE:
4364         case WHILE:
4365         case FOREACH:
4366         case AT:
4367         case BANG:
4368         case TILDE:
4369         case PLUS_PLUS:
4370         case MINUS_MINUS:
4371         case PLUS:
4372         case MINUS:
4373         case BIT_AND:
4374         case INTEGER_LITERAL:
4375         case FLOATING_POINT_LITERAL:
4376         case STRING_LITERAL:
4377         case DOUBLEQUOTE:
4378         case DOLLAR:
4379         case IDENTIFIER:
4380         case LPAREN:
4381         case LBRACE:
4382         case SEMICOLON:
4383           statement = Statement();
4384                               stmts.add(statement);
4385           break;
4386         case PHPEND:
4387           statement = htmlBlock();
4388                               if (statement != null) {stmts.add(statement);}
4389           break;
4390         default:
4391           jj_la1[106] = jj_gen;
4392           jj_consume_token(-1);
4393           throw new ParseException();
4394         }
4395       }
4396     endStatements = SimpleCharStream.getPosition();
4397       label_33:
4398       while (true) {
4399         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
4400         case ELSEIF:
4401           ;
4402           break;
4403         default:
4404           jj_la1[107] = jj_gen;
4405           break label_33;
4406         }
4407         elseifStatement = ElseIfStatementColon();
4408                                               elseIfList.add(elseifStatement);
4409       }
4410       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
4411       case ELSE:
4412         elseStatement = ElseStatementColon();
4413         break;
4414       default:
4415         jj_la1[108] = jj_gen;
4416         ;
4417       }
4418    try {
4419   setMarker(fileToParse,
4420             "Ugly syntax detected, you should if () {...} instead of if (): ... endif;",
4421             start,
4422             end,
4423             INFO,
4424             "Line " + token.beginLine);
4425   } catch (CoreException e) {
4426     PHPeclipsePlugin.log(e);
4427   }
4428       try {
4429         jj_consume_token(ENDIF);
4430       } catch (ParseException e) {
4431     errorMessage = "'endif' expected";
4432     errorLevel   = ERROR;
4433     errorStart = e.currentToken.sourceStart;
4434     errorEnd   = e.currentToken.sourceEnd;
4435     {if (true) throw e;}
4436       }
4437       try {
4438         jj_consume_token(SEMICOLON);
4439       } catch (ParseException e) {
4440     errorMessage = "';' expected after 'endif' keyword";
4441     errorLevel   = ERROR;
4442     errorStart = e.currentToken.sourceStart;
4443     errorEnd   = e.currentToken.sourceEnd;
4444     {if (true) throw e;}
4445       }
4446     elseIfs = new ElseIf[elseIfList.size()];
4447     elseIfList.toArray(elseIfs);
4448     if (stmts.size() == 1) {
4449       {if (true) return new IfStatement(condition,
4450                              (Statement) stmts.get(0),
4451                               elseIfs,
4452                               elseStatement,
4453                               pos,
4454                               SimpleCharStream.getPosition());}
4455     } else {
4456       statementsArray = new Statement[stmts.size()];
4457       stmts.toArray(statementsArray);
4458       {if (true) return new IfStatement(condition,
4459                              new Block(statementsArray,pos,endStatements),
4460                              elseIfs,
4461                              elseStatement,
4462                              pos,
4463                              SimpleCharStream.getPosition());}
4464     }
4465       break;
4466     case PHPEND:
4467     case IF:
4468     case ARRAY:
4469     case BREAK:
4470     case LIST:
4471     case PRINT:
4472     case ECHO:
4473     case INCLUDE:
4474     case REQUIRE:
4475     case INCLUDE_ONCE:
4476     case REQUIRE_ONCE:
4477     case GLOBAL:
4478     case DEFINE:
4479     case STATIC:
4480     case CONTINUE:
4481     case DO:
4482     case FOR:
4483     case NEW:
4484     case NULL:
4485     case RETURN:
4486     case SWITCH:
4487     case TRUE:
4488     case FALSE:
4489     case WHILE:
4490     case FOREACH:
4491     case AT:
4492     case BANG:
4493     case TILDE:
4494     case PLUS_PLUS:
4495     case MINUS_MINUS:
4496     case PLUS:
4497     case MINUS:
4498     case BIT_AND:
4499     case INTEGER_LITERAL:
4500     case FLOATING_POINT_LITERAL:
4501     case STRING_LITERAL:
4502     case DOUBLEQUOTE:
4503     case DOLLAR:
4504     case IDENTIFIER:
4505     case LPAREN:
4506     case LBRACE:
4507     case SEMICOLON:
4508       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
4509       case IF:
4510       case ARRAY:
4511       case BREAK:
4512       case LIST:
4513       case PRINT:
4514       case ECHO:
4515       case INCLUDE:
4516       case REQUIRE:
4517       case INCLUDE_ONCE:
4518       case REQUIRE_ONCE:
4519       case GLOBAL:
4520       case DEFINE:
4521       case STATIC:
4522       case CONTINUE:
4523       case DO:
4524       case FOR:
4525       case NEW:
4526       case NULL:
4527       case RETURN:
4528       case SWITCH:
4529       case TRUE:
4530       case FALSE:
4531       case WHILE:
4532       case FOREACH:
4533       case AT:
4534       case BANG:
4535       case TILDE:
4536       case PLUS_PLUS:
4537       case MINUS_MINUS:
4538       case PLUS:
4539       case MINUS:
4540       case BIT_AND:
4541       case INTEGER_LITERAL:
4542       case FLOATING_POINT_LITERAL:
4543       case STRING_LITERAL:
4544       case DOUBLEQUOTE:
4545       case DOLLAR:
4546       case IDENTIFIER:
4547       case LPAREN:
4548       case LBRACE:
4549       case SEMICOLON:
4550         stmt = Statement();
4551         break;
4552       case PHPEND:
4553         stmt = htmlBlock();
4554         break;
4555       default:
4556         jj_la1[109] = jj_gen;
4557         jj_consume_token(-1);
4558         throw new ParseException();
4559       }
4560       label_34:
4561       while (true) {
4562         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
4563         case ELSEIF:
4564           ;
4565           break;
4566         default:
4567           jj_la1[110] = jj_gen;
4568           break label_34;
4569         }
4570         elseifStatement = ElseIfStatement();
4571                                                       elseIfList.add(elseifStatement);
4572       }
4573       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
4574       case ELSE:
4575         jj_consume_token(ELSE);
4576         try {
4577        pos = SimpleCharStream.getPosition();
4578           statement = Statement();
4579        elseStatement = new Else(statement,pos,SimpleCharStream.getPosition());
4580         } catch (ParseException e) {
4581       if (errorMessage != null) {
4582         {if (true) throw e;}
4583       }
4584       errorMessage = "unexpected token '"+e.currentToken.next.image+"', a statement was expected";
4585       errorLevel   = ERROR;
4586       errorStart = e.currentToken.sourceStart;
4587       errorEnd   = e.currentToken.sourceEnd;
4588       {if (true) throw e;}
4589         }
4590         break;
4591       default:
4592         jj_la1[111] = jj_gen;
4593         ;
4594       }
4595     elseIfs = new ElseIf[elseIfList.size()];
4596     elseIfList.toArray(elseIfs);
4597     {if (true) return new IfStatement(condition,
4598                            stmt,
4599                            elseIfs,
4600                            elseStatement,
4601                            pos,
4602                            SimpleCharStream.getPosition());}
4603       break;
4604     default:
4605       jj_la1[112] = jj_gen;
4606       jj_consume_token(-1);
4607       throw new ParseException();
4608     }
4609     throw new Error("Missing return statement in function");
4610   }
4611
4612   static final public ElseIf ElseIfStatementColon() throws ParseException {
4613   final Expression condition;
4614   Statement statement;
4615   final ArrayList list = new ArrayList();
4616   final Token elseifToken;
4617     elseifToken = jj_consume_token(ELSEIF);
4618     condition = Condition("elseif");
4619     jj_consume_token(COLON);
4620     label_35:
4621     while (true) {
4622       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
4623       case PHPEND:
4624       case IF:
4625       case ARRAY:
4626       case BREAK:
4627       case LIST:
4628       case PRINT:
4629       case ECHO:
4630       case INCLUDE:
4631       case REQUIRE:
4632       case INCLUDE_ONCE:
4633       case REQUIRE_ONCE:
4634       case GLOBAL:
4635       case DEFINE:
4636       case STATIC:
4637       case CONTINUE:
4638       case DO:
4639       case FOR:
4640       case NEW:
4641       case NULL:
4642       case RETURN:
4643       case SWITCH:
4644       case TRUE:
4645       case FALSE:
4646       case WHILE:
4647       case FOREACH:
4648       case AT:
4649       case BANG:
4650       case TILDE:
4651       case PLUS_PLUS:
4652       case MINUS_MINUS:
4653       case PLUS:
4654       case MINUS:
4655       case BIT_AND:
4656       case INTEGER_LITERAL:
4657       case FLOATING_POINT_LITERAL:
4658       case STRING_LITERAL:
4659       case DOUBLEQUOTE:
4660       case DOLLAR:
4661       case IDENTIFIER:
4662       case LPAREN:
4663       case LBRACE:
4664       case SEMICOLON:
4665         ;
4666         break;
4667       default:
4668         jj_la1[113] = jj_gen;
4669         break label_35;
4670       }
4671       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
4672       case IF:
4673       case ARRAY:
4674       case BREAK:
4675       case LIST:
4676       case PRINT:
4677       case ECHO:
4678       case INCLUDE:
4679       case REQUIRE:
4680       case INCLUDE_ONCE:
4681       case REQUIRE_ONCE:
4682       case GLOBAL:
4683       case DEFINE:
4684       case STATIC:
4685       case CONTINUE:
4686       case DO:
4687       case FOR:
4688       case NEW:
4689       case NULL:
4690       case RETURN:
4691       case SWITCH:
4692       case TRUE:
4693       case FALSE:
4694       case WHILE:
4695       case FOREACH:
4696       case AT:
4697       case BANG:
4698       case TILDE:
4699       case PLUS_PLUS:
4700       case MINUS_MINUS:
4701       case PLUS:
4702       case MINUS:
4703       case BIT_AND:
4704       case INTEGER_LITERAL:
4705       case FLOATING_POINT_LITERAL:
4706       case STRING_LITERAL:
4707       case DOUBLEQUOTE:
4708       case DOLLAR:
4709       case IDENTIFIER:
4710       case LPAREN:
4711       case LBRACE:
4712       case SEMICOLON:
4713         statement = Statement();
4714                                       list.add(statement);
4715         break;
4716       case PHPEND:
4717         statement = htmlBlock();
4718                                       if (statement != null) {list.add(statement);}
4719         break;
4720       default:
4721         jj_la1[114] = jj_gen;
4722         jj_consume_token(-1);
4723         throw new ParseException();
4724       }
4725     }
4726   final int sizeList = list.size();
4727   final Statement[] stmtsArray = new Statement[sizeList];
4728   list.toArray(stmtsArray);
4729   {if (true) return new ElseIf(condition,stmtsArray ,
4730                     elseifToken.sourceStart,
4731                     stmtsArray[sizeList-1].sourceEnd);}
4732     throw new Error("Missing return statement in function");
4733   }
4734
4735   static final public Else ElseStatementColon() throws ParseException {
4736   Statement statement;
4737   final ArrayList list = new ArrayList();
4738   final Token elseToken;
4739     elseToken = jj_consume_token(ELSE);
4740     jj_consume_token(COLON);
4741     label_36:
4742     while (true) {
4743       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
4744       case PHPEND:
4745       case IF:
4746       case ARRAY:
4747       case BREAK:
4748       case LIST:
4749       case PRINT:
4750       case ECHO:
4751       case INCLUDE:
4752       case REQUIRE:
4753       case INCLUDE_ONCE:
4754       case REQUIRE_ONCE:
4755       case GLOBAL:
4756       case DEFINE:
4757       case STATIC:
4758       case CONTINUE:
4759       case DO:
4760       case FOR:
4761       case NEW:
4762       case NULL:
4763       case RETURN:
4764       case SWITCH:
4765       case TRUE:
4766       case FALSE:
4767       case WHILE:
4768       case FOREACH:
4769       case AT:
4770       case BANG:
4771       case TILDE:
4772       case PLUS_PLUS:
4773       case MINUS_MINUS:
4774       case PLUS:
4775       case MINUS:
4776       case BIT_AND:
4777       case INTEGER_LITERAL:
4778       case FLOATING_POINT_LITERAL:
4779       case STRING_LITERAL:
4780       case DOUBLEQUOTE:
4781       case DOLLAR:
4782       case IDENTIFIER:
4783       case LPAREN:
4784       case LBRACE:
4785       case SEMICOLON:
4786         ;
4787         break;
4788       default:
4789         jj_la1[115] = jj_gen;
4790         break label_36;
4791       }
4792       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
4793       case IF:
4794       case ARRAY:
4795       case BREAK:
4796       case LIST:
4797       case PRINT:
4798       case ECHO:
4799       case INCLUDE:
4800       case REQUIRE:
4801       case INCLUDE_ONCE:
4802       case REQUIRE_ONCE:
4803       case GLOBAL:
4804       case DEFINE:
4805       case STATIC:
4806       case CONTINUE:
4807       case DO:
4808       case FOR:
4809       case NEW:
4810       case NULL:
4811       case RETURN:
4812       case SWITCH:
4813       case TRUE:
4814       case FALSE:
4815       case WHILE:
4816       case FOREACH:
4817       case AT:
4818       case BANG:
4819       case TILDE:
4820       case PLUS_PLUS:
4821       case MINUS_MINUS:
4822       case PLUS:
4823       case MINUS:
4824       case BIT_AND:
4825       case INTEGER_LITERAL:
4826       case FLOATING_POINT_LITERAL:
4827       case STRING_LITERAL:
4828       case DOUBLEQUOTE:
4829       case DOLLAR:
4830       case IDENTIFIER:
4831       case LPAREN:
4832       case LBRACE:
4833       case SEMICOLON:
4834         statement = Statement();
4835                                                          list.add(statement);
4836         break;
4837       case PHPEND:
4838         statement = htmlBlock();
4839                                              if (statement != null) {list.add(statement);}
4840         break;
4841       default:
4842         jj_la1[116] = jj_gen;
4843         jj_consume_token(-1);
4844         throw new ParseException();
4845       }
4846     }
4847   final int sizeList = list.size();
4848   final Statement[] stmtsArray = new Statement[sizeList];
4849   list.toArray(stmtsArray);
4850   {if (true) return new Else(stmtsArray,elseToken.sourceStart,stmtsArray[sizeList-1].sourceEnd);}
4851     throw new Error("Missing return statement in function");
4852   }
4853
4854   static final public ElseIf ElseIfStatement() throws ParseException {
4855   final Expression condition;
4856   //final Statement statement;
4857   final Token elseifToken;
4858   final Statement[] statement = new Statement[1];
4859     elseifToken = jj_consume_token(ELSEIF);
4860     condition = Condition("elseif");
4861     statement[0] = Statement();
4862   {if (true) return new ElseIf(condition,statement,elseifToken.sourceStart,statement[0].sourceEnd);}
4863     throw new Error("Missing return statement in function");
4864   }
4865
4866   static final public WhileStatement WhileStatement() throws ParseException {
4867   final Expression condition;
4868   final Statement action;
4869   final Token whileToken;
4870     whileToken = jj_consume_token(WHILE);
4871     condition = Condition("while");
4872     action = WhileStatement0(whileToken.sourceStart,whileToken.sourceEnd);
4873      {if (true) return new WhileStatement(condition,action,whileToken.sourceStart,action.sourceEnd);}
4874     throw new Error("Missing return statement in function");
4875   }
4876
4877   static final public Statement WhileStatement0(final int start, final int end) throws ParseException {
4878   Statement statement;
4879   final ArrayList stmts = new ArrayList();
4880   final int pos = SimpleCharStream.getPosition();
4881     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
4882     case COLON:
4883       jj_consume_token(COLON);
4884       label_37:
4885       while (true) {
4886         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
4887         case IF:
4888         case ARRAY:
4889         case BREAK:
4890         case LIST:
4891         case PRINT:
4892         case ECHO:
4893         case INCLUDE:
4894         case REQUIRE:
4895         case INCLUDE_ONCE:
4896         case REQUIRE_ONCE:
4897         case GLOBAL:
4898         case DEFINE:
4899         case STATIC:
4900         case CONTINUE:
4901         case DO:
4902         case FOR:
4903         case NEW:
4904         case NULL:
4905         case RETURN:
4906         case SWITCH:
4907         case TRUE:
4908         case FALSE:
4909         case WHILE:
4910         case FOREACH:
4911         case AT:
4912         case BANG:
4913         case TILDE:
4914         case PLUS_PLUS:
4915         case MINUS_MINUS:
4916         case PLUS:
4917         case MINUS:
4918         case BIT_AND:
4919         case INTEGER_LITERAL:
4920         case FLOATING_POINT_LITERAL:
4921         case STRING_LITERAL:
4922         case DOUBLEQUOTE:
4923         case DOLLAR:
4924         case IDENTIFIER:
4925         case LPAREN:
4926         case LBRACE:
4927         case SEMICOLON:
4928           ;
4929           break;
4930         default:
4931           jj_la1[117] = jj_gen;
4932           break label_37;
4933         }
4934         statement = Statement();
4935                                     stmts.add(statement);
4936       }
4937    try {
4938   setMarker(fileToParse,
4939             "Ugly syntax detected, you should while () {...} instead of while (): ... endwhile;",
4940             start,
4941             end,
4942             INFO,
4943             "Line " + token.beginLine);
4944   } catch (CoreException e) {
4945     PHPeclipsePlugin.log(e);
4946   }
4947       try {
4948         jj_consume_token(ENDWHILE);
4949       } catch (ParseException e) {
4950     errorMessage = "'endwhile' expected";
4951     errorLevel   = ERROR;
4952     errorStart = e.currentToken.sourceStart;
4953     errorEnd   = e.currentToken.sourceEnd;
4954     {if (true) throw e;}
4955       }
4956       try {
4957         jj_consume_token(SEMICOLON);
4958     final Statement[] stmtsArray = new Statement[stmts.size()];
4959     stmts.toArray(stmtsArray);
4960     {if (true) return new Block(stmtsArray,pos,SimpleCharStream.getPosition());}
4961       } catch (ParseException e) {
4962     errorMessage = "';' expected after 'endwhile' keyword";
4963     errorLevel   = ERROR;
4964     errorStart = e.currentToken.sourceStart;
4965     errorEnd   = e.currentToken.sourceEnd;
4966     {if (true) throw e;}
4967       }
4968       break;
4969     case IF:
4970     case ARRAY:
4971     case BREAK:
4972     case LIST:
4973     case PRINT:
4974     case ECHO:
4975     case INCLUDE:
4976     case REQUIRE:
4977     case INCLUDE_ONCE:
4978     case REQUIRE_ONCE:
4979     case GLOBAL:
4980     case DEFINE:
4981     case STATIC:
4982     case CONTINUE:
4983     case DO:
4984     case FOR:
4985     case NEW:
4986     case NULL:
4987     case RETURN:
4988     case SWITCH:
4989     case TRUE:
4990     case FALSE:
4991     case WHILE:
4992     case FOREACH:
4993     case AT:
4994     case BANG:
4995     case TILDE:
4996     case PLUS_PLUS:
4997     case MINUS_MINUS:
4998     case PLUS:
4999     case MINUS:
5000     case BIT_AND:
5001     case INTEGER_LITERAL:
5002     case FLOATING_POINT_LITERAL:
5003     case STRING_LITERAL:
5004     case DOUBLEQUOTE:
5005     case DOLLAR:
5006     case IDENTIFIER:
5007     case LPAREN:
5008     case LBRACE:
5009     case SEMICOLON:
5010       statement = Statement();
5011    {if (true) return statement;}
5012       break;
5013     default:
5014       jj_la1[118] = jj_gen;
5015       jj_consume_token(-1);
5016       throw new ParseException();
5017     }
5018     throw new Error("Missing return statement in function");
5019   }
5020
5021   static final public DoStatement DoStatement() throws ParseException {
5022   final Statement action;
5023   final Expression condition;
5024   final Token token;
5025   Token token2 = null;
5026     token = jj_consume_token(DO);
5027     action = Statement();
5028     jj_consume_token(WHILE);
5029     condition = Condition("while");
5030     try {
5031       token2 = jj_consume_token(SEMICOLON);
5032     } catch (ParseException e) {
5033     errorMessage = "unexpected token : '"+ e.currentToken.next.image +"'. A ';' was expected";
5034     errorLevel   = ERROR;
5035     errorStart = condition.sourceEnd+1;
5036     errorEnd   = condition.sourceEnd+1;
5037     processParseExceptionDebug(e);
5038     }
5039     if (token2 == null) {
5040       {if (true) return new DoStatement(condition,action,token.sourceStart,condition.sourceEnd);}
5041     }
5042     {if (true) return new DoStatement(condition,action,token.sourceStart,token2.sourceEnd);}
5043     throw new Error("Missing return statement in function");
5044   }
5045
5046   static final public ForeachStatement ForeachStatement() throws ParseException {
5047   Statement statement = null;
5048   Expression expression = null;
5049   ArrayVariableDeclaration variable = null;
5050   Token foreachToken;
5051   Token lparenToken = null;
5052   Token asToken = null;
5053   Token rparenToken = null;
5054   int pos;
5055     foreachToken = jj_consume_token(FOREACH);
5056     try {
5057       lparenToken = jj_consume_token(LPAREN);
5058      pos = lparenToken.sourceEnd+1;
5059     } catch (ParseException e) {
5060     errorMessage = "'(' expected after 'foreach' keyword";
5061     errorLevel   = ERROR;
5062     errorStart = e.currentToken.sourceStart;
5063     errorEnd   = e.currentToken.sourceEnd;
5064     processParseExceptionDebug(e);
5065     {pos = foreachToken.sourceEnd+1;}
5066     }
5067     try {
5068       expression = Expression();
5069      pos = expression.sourceEnd+1;
5070     } catch (ParseException e) {
5071     errorMessage = "variable expected";
5072     errorLevel   = ERROR;
5073     errorStart = e.currentToken.sourceStart;
5074     errorEnd   = e.currentToken.sourceEnd;
5075     processParseExceptionDebug(e);
5076     }
5077     try {
5078       asToken = jj_consume_token(AS);
5079      pos = asToken.sourceEnd+1;
5080     } catch (ParseException e) {
5081     errorMessage = "'as' expected";
5082     errorLevel   = ERROR;
5083     errorStart = e.currentToken.sourceStart;
5084     errorEnd   = e.currentToken.sourceEnd;
5085     processParseExceptionDebug(e);
5086     }
5087     try {
5088       variable = ArrayVariable();
5089      pos = variable.sourceEnd+1;
5090     } catch (ParseException e) {
5091     if (errorMessage != null) {if (true) throw e;}
5092     errorMessage = "variable expected";
5093     errorLevel   = ERROR;
5094     errorStart = e.currentToken.sourceStart;
5095     errorEnd   = e.currentToken.sourceEnd;
5096     processParseExceptionDebug(e);
5097     }
5098     try {
5099       rparenToken = jj_consume_token(RPAREN);
5100      pos = rparenToken.sourceEnd+1;
5101     } catch (ParseException e) {
5102     errorMessage = "')' expected after 'foreach' keyword";
5103     errorLevel   = ERROR;
5104     errorStart = e.currentToken.sourceStart;
5105     errorEnd   = e.currentToken.sourceEnd;
5106     processParseExceptionDebug(e);
5107     }
5108     try {
5109       statement = Statement();
5110      pos = rparenToken.sourceEnd+1;
5111     } catch (ParseException e) {
5112     if (errorMessage != null) {if (true) throw e;}
5113     errorMessage = "statement expected";
5114     errorLevel   = ERROR;
5115     errorStart = e.currentToken.sourceStart;
5116     errorEnd   = e.currentToken.sourceEnd;
5117     processParseExceptionDebug(e);
5118     }
5119    {if (true) return new ForeachStatement(expression,
5120                                variable,
5121                                statement,
5122                                foreachToken.sourceStart,
5123                                statement.sourceEnd);}
5124     throw new Error("Missing return statement in function");
5125   }
5126
5127 /**
5128  * a for declaration.
5129  * @return a node representing the for statement
5130  */
5131   static final public ForStatement ForStatement() throws ParseException {
5132 final Token token,tokenEndFor,token2,tokenColon;
5133 int pos;
5134 Expression[] initializations = null;
5135 Expression condition = null;
5136 Expression[] increments = null;
5137 Statement action;
5138 final ArrayList list = new ArrayList();
5139     token = jj_consume_token(FOR);
5140     try {
5141       jj_consume_token(LPAREN);
5142     } catch (ParseException e) {
5143     errorMessage = "'(' expected after 'for' keyword";
5144     errorLevel   = ERROR;
5145     errorStart = token.sourceEnd;
5146     errorEnd   = token.sourceEnd +1;
5147     processParseExceptionDebug(e);
5148     }
5149     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
5150     case ARRAY:
5151     case LIST:
5152     case PRINT:
5153     case NEW:
5154     case NULL:
5155     case TRUE:
5156     case FALSE:
5157     case AT:
5158     case BANG:
5159     case TILDE:
5160     case PLUS_PLUS:
5161     case MINUS_MINUS:
5162     case PLUS:
5163     case MINUS:
5164     case BIT_AND:
5165     case INTEGER_LITERAL:
5166     case FLOATING_POINT_LITERAL:
5167     case STRING_LITERAL:
5168     case DOUBLEQUOTE:
5169     case DOLLAR:
5170     case IDENTIFIER:
5171     case LPAREN:
5172       initializations = ForInit();
5173       break;
5174     default:
5175       jj_la1[119] = jj_gen;
5176       ;
5177     }
5178     jj_consume_token(SEMICOLON);
5179     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
5180     case ARRAY:
5181     case LIST:
5182     case PRINT:
5183     case NEW:
5184     case NULL:
5185     case TRUE:
5186     case FALSE:
5187     case AT:
5188     case BANG:
5189     case TILDE:
5190     case PLUS_PLUS:
5191     case MINUS_MINUS:
5192     case PLUS:
5193     case MINUS:
5194     case BIT_AND:
5195     case INTEGER_LITERAL:
5196     case FLOATING_POINT_LITERAL:
5197     case STRING_LITERAL:
5198     case DOUBLEQUOTE:
5199     case DOLLAR:
5200     case IDENTIFIER:
5201     case LPAREN:
5202       condition = Expression();
5203       break;
5204     default:
5205       jj_la1[120] = jj_gen;
5206       ;
5207     }
5208     jj_consume_token(SEMICOLON);
5209     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
5210     case ARRAY:
5211     case LIST:
5212     case PRINT:
5213     case NEW:
5214     case NULL:
5215     case TRUE:
5216     case FALSE:
5217     case AT:
5218     case BANG:
5219     case TILDE:
5220     case PLUS_PLUS:
5221     case MINUS_MINUS:
5222     case PLUS:
5223     case MINUS:
5224     case BIT_AND:
5225     case INTEGER_LITERAL:
5226     case FLOATING_POINT_LITERAL:
5227     case STRING_LITERAL:
5228     case DOUBLEQUOTE:
5229     case DOLLAR:
5230     case IDENTIFIER:
5231     case LPAREN:
5232       increments = StatementExpressionList();
5233       break;
5234     default:
5235       jj_la1[121] = jj_gen;
5236       ;
5237     }
5238     jj_consume_token(RPAREN);
5239     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
5240     case IF:
5241     case ARRAY:
5242     case BREAK:
5243     case LIST:
5244     case PRINT:
5245     case ECHO:
5246     case INCLUDE:
5247     case REQUIRE:
5248     case INCLUDE_ONCE:
5249     case REQUIRE_ONCE:
5250     case GLOBAL:
5251     case DEFINE:
5252     case STATIC:
5253     case CONTINUE:
5254     case DO:
5255     case FOR:
5256     case NEW:
5257     case NULL:
5258     case RETURN:
5259     case SWITCH:
5260     case TRUE:
5261     case FALSE:
5262     case WHILE:
5263     case FOREACH:
5264     case AT:
5265     case BANG:
5266     case TILDE:
5267     case PLUS_PLUS:
5268     case MINUS_MINUS:
5269     case PLUS:
5270     case MINUS:
5271     case BIT_AND:
5272     case INTEGER_LITERAL:
5273     case FLOATING_POINT_LITERAL:
5274     case STRING_LITERAL:
5275     case DOUBLEQUOTE:
5276     case DOLLAR:
5277     case IDENTIFIER:
5278     case LPAREN:
5279     case LBRACE:
5280     case SEMICOLON:
5281       action = Statement();
5282        {if (true) return new ForStatement(initializations,
5283                                condition,
5284                                increments,
5285                                action,
5286                                token.sourceStart,
5287                                action.sourceEnd);}
5288       break;
5289     case COLON:
5290       tokenColon = jj_consume_token(COLON);
5291                             pos = tokenColon.sourceEnd+1;
5292       label_38:
5293       while (true) {
5294         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
5295         case IF:
5296         case ARRAY:
5297         case BREAK:
5298         case LIST:
5299         case PRINT:
5300         case ECHO:
5301         case INCLUDE:
5302         case REQUIRE:
5303         case INCLUDE_ONCE:
5304         case REQUIRE_ONCE:
5305         case GLOBAL:
5306         case DEFINE:
5307         case STATIC:
5308         case CONTINUE:
5309         case DO:
5310         case FOR:
5311         case NEW:
5312         case NULL:
5313         case RETURN:
5314         case SWITCH:
5315         case TRUE:
5316         case FALSE:
5317         case WHILE:
5318         case FOREACH:
5319         case AT:
5320         case BANG:
5321         case TILDE:
5322         case PLUS_PLUS:
5323         case MINUS_MINUS:
5324         case PLUS:
5325         case MINUS:
5326         case BIT_AND:
5327         case INTEGER_LITERAL:
5328         case FLOATING_POINT_LITERAL:
5329         case STRING_LITERAL:
5330         case DOUBLEQUOTE:
5331         case DOLLAR:
5332         case IDENTIFIER:
5333         case LPAREN:
5334         case LBRACE:
5335         case SEMICOLON:
5336           ;
5337           break;
5338         default:
5339           jj_la1[122] = jj_gen;
5340           break label_38;
5341         }
5342         action = Statement();
5343                              list.add(action);pos = action.sourceEnd+1;
5344       }
5345         try {
5346         setMarker(fileToParse,
5347                   "Ugly syntax detected, you should for () {...} instead of for (): ... endfor;",
5348                   token.sourceStart,
5349                   token.sourceEnd,
5350                   INFO,
5351                   "Line " + token.beginLine);
5352         } catch (CoreException e) {
5353           PHPeclipsePlugin.log(e);
5354         }
5355       try {
5356         tokenEndFor = jj_consume_token(ENDFOR);
5357          pos = tokenEndFor.sourceEnd+1;
5358       } catch (ParseException e) {
5359         errorMessage = "'endfor' expected";
5360         errorLevel   = ERROR;
5361         errorStart = pos;
5362         errorEnd   = pos;
5363         processParseExceptionDebug(e);
5364       }
5365       try {
5366         token2 = jj_consume_token(SEMICOLON);
5367          pos = token2.sourceEnd+1;
5368       } catch (ParseException e) {
5369         errorMessage = "';' expected after 'endfor' keyword";
5370         errorLevel   = ERROR;
5371         errorStart = pos;
5372         errorEnd   = pos;
5373         processParseExceptionDebug(e);
5374       }
5375       final Statement[] stmtsArray = new Statement[list.size()];
5376       list.toArray(stmtsArray);
5377       {if (true) return new ForStatement(initializations,
5378                               condition,
5379                               increments,
5380                               new Block(stmtsArray,
5381                                         stmtsArray[0].sourceStart,
5382                                         stmtsArray[stmtsArray.length-1].sourceEnd),
5383                               token.sourceStart,
5384                               pos);}
5385       break;
5386     default:
5387       jj_la1[123] = jj_gen;
5388       jj_consume_token(-1);
5389       throw new ParseException();
5390     }
5391     throw new Error("Missing return statement in function");
5392   }
5393
5394   static final public Expression[] ForInit() throws ParseException {
5395   final Expression[] exprs;
5396     if (jj_2_5(2147483647)) {
5397       exprs = LocalVariableDeclaration();
5398    {if (true) return exprs;}
5399     } else {
5400       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
5401       case ARRAY:
5402       case LIST:
5403       case PRINT:
5404       case NEW:
5405       case NULL:
5406       case TRUE:
5407       case FALSE:
5408       case AT:
5409       case BANG:
5410       case TILDE:
5411       case PLUS_PLUS:
5412       case MINUS_MINUS:
5413       case PLUS:
5414       case MINUS:
5415       case BIT_AND:
5416       case INTEGER_LITERAL:
5417       case FLOATING_POINT_LITERAL:
5418       case STRING_LITERAL:
5419       case DOUBLEQUOTE:
5420       case DOLLAR:
5421       case IDENTIFIER:
5422       case LPAREN:
5423         exprs = StatementExpressionList();
5424    {if (true) return exprs;}
5425         break;
5426       default:
5427         jj_la1[124] = jj_gen;
5428         jj_consume_token(-1);
5429         throw new ParseException();
5430       }
5431     }
5432     throw new Error("Missing return statement in function");
5433   }
5434
5435   static final public Expression[] StatementExpressionList() throws ParseException {
5436   final ArrayList list = new ArrayList();
5437   final Expression expr;
5438     expr = Expression();
5439                          list.add(expr);
5440     label_39:
5441     while (true) {
5442       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
5443       case COMMA:
5444         ;
5445         break;
5446       default:
5447         jj_la1[125] = jj_gen;
5448         break label_39;
5449       }
5450       jj_consume_token(COMMA);
5451       Expression();
5452                          list.add(expr);
5453     }
5454     final Expression[] exprsArray = new Expression[list.size()];
5455     list.toArray(exprsArray);
5456     {if (true) return exprsArray;}
5457     throw new Error("Missing return statement in function");
5458   }
5459
5460   static final public Continue ContinueStatement() throws ParseException {
5461   Expression expr = null;
5462   final Token token;
5463   Token token2 = null;
5464     token = jj_consume_token(CONTINUE);
5465     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
5466     case ARRAY:
5467     case LIST:
5468     case PRINT:
5469     case NEW:
5470     case NULL:
5471     case TRUE:
5472     case FALSE:
5473     case AT:
5474     case BANG:
5475     case TILDE:
5476     case PLUS_PLUS:
5477     case MINUS_MINUS:
5478     case PLUS:
5479     case MINUS:
5480     case BIT_AND:
5481     case INTEGER_LITERAL:
5482     case FLOATING_POINT_LITERAL:
5483     case STRING_LITERAL:
5484     case DOUBLEQUOTE:
5485     case DOLLAR:
5486     case IDENTIFIER:
5487     case LPAREN:
5488       expr = Expression();
5489       break;
5490     default:
5491       jj_la1[126] = jj_gen;
5492       ;
5493     }
5494     try {
5495       token2 = jj_consume_token(SEMICOLON);
5496     } catch (ParseException e) {
5497     errorMessage = "';' expected after 'continue' statement";
5498     errorLevel   = ERROR;
5499     if (expr == null) {
5500       errorStart = token.sourceEnd+1;
5501       errorEnd   = token.sourceEnd+1;
5502     } else {
5503       errorStart = expr.sourceEnd+1;
5504       errorEnd   = expr.sourceEnd+1;
5505     }
5506     processParseExceptionDebug(e);
5507     }
5508     if (token2 == null) {
5509       if (expr == null) {
5510         {if (true) return new Continue(expr,token.sourceStart,token.sourceEnd);}
5511       }
5512       {if (true) return new Continue(expr,token.sourceStart,expr.sourceEnd);}
5513     }
5514     {if (true) return new Continue(expr,token.sourceStart,token2.sourceEnd);}
5515     throw new Error("Missing return statement in function");
5516   }
5517
5518   static final public ReturnStatement ReturnStatement() throws ParseException {
5519   Expression expr = null;
5520   final Token token;
5521   Token token2 = null;
5522     token = jj_consume_token(RETURN);
5523     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
5524     case ARRAY:
5525     case LIST:
5526     case PRINT:
5527     case NEW:
5528     case NULL:
5529     case TRUE:
5530     case FALSE:
5531     case AT:
5532     case BANG:
5533     case TILDE:
5534     case PLUS_PLUS:
5535     case MINUS_MINUS:
5536     case PLUS:
5537     case MINUS:
5538     case BIT_AND:
5539     case INTEGER_LITERAL:
5540     case FLOATING_POINT_LITERAL:
5541     case STRING_LITERAL:
5542     case DOUBLEQUOTE:
5543     case DOLLAR:
5544     case IDENTIFIER:
5545     case LPAREN:
5546       expr = Expression();
5547       break;
5548     default:
5549       jj_la1[127] = jj_gen;
5550       ;
5551     }
5552     try {
5553       token2 = jj_consume_token(SEMICOLON);
5554     } catch (ParseException e) {
5555     errorMessage = "';' expected after 'return' statement";
5556     errorLevel   = ERROR;
5557     if (expr == null) {
5558       errorStart = token.sourceEnd+1;
5559       errorEnd   = token.sourceEnd+1;
5560     } else {
5561       errorStart = expr.sourceEnd+1;
5562       errorEnd   = expr.sourceEnd+1;
5563     }
5564     processParseExceptionDebug(e);
5565     }
5566     if (token2 == null) {
5567       if (expr == null) {
5568         {if (true) return new ReturnStatement(expr,token.sourceStart,token.sourceEnd);}
5569       }
5570       {if (true) return new ReturnStatement(expr,token.sourceStart,expr.sourceEnd);}
5571     }
5572     {if (true) return new ReturnStatement(expr,token.sourceStart,token2.sourceEnd);}
5573     throw new Error("Missing return statement in function");
5574   }
5575
5576   static final private boolean jj_2_1(int xla) {
5577     jj_la = xla; jj_lastpos = jj_scanpos = token;
5578     boolean retval = !jj_3_1();
5579     jj_save(0, xla);
5580     return retval;
5581   }
5582
5583   static final private boolean jj_2_2(int xla) {
5584     jj_la = xla; jj_lastpos = jj_scanpos = token;
5585     boolean retval = !jj_3_2();
5586     jj_save(1, xla);
5587     return retval;
5588   }
5589
5590   static final private boolean jj_2_3(int xla) {
5591     jj_la = xla; jj_lastpos = jj_scanpos = token;
5592     boolean retval = !jj_3_3();
5593     jj_save(2, xla);
5594     return retval;
5595   }
5596
5597   static final private boolean jj_2_4(int xla) {
5598     jj_la = xla; jj_lastpos = jj_scanpos = token;
5599     boolean retval = !jj_3_4();
5600     jj_save(3, xla);
5601     return retval;
5602   }
5603
5604   static final private boolean jj_2_5(int xla) {
5605     jj_la = xla; jj_lastpos = jj_scanpos = token;
5606     boolean retval = !jj_3_5();
5607     jj_save(4, xla);
5608     return retval;
5609   }
5610
5611   static final private boolean jj_3R_210() {
5612     if (jj_3R_116()) return true;
5613     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5614     return false;
5615   }
5616
5617   static final private boolean jj_3R_209() {
5618     if (jj_3R_50()) return true;
5619     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5620     return false;
5621   }
5622
5623   static final private boolean jj_3R_109() {
5624     if (jj_3R_114()) return true;
5625     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5626     Token xsp;
5627     while (true) {
5628       xsp = jj_scanpos;
5629       if (jj_3R_115()) { jj_scanpos = xsp; break; }
5630       if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5631     }
5632     return false;
5633   }
5634
5635   static final private boolean jj_3R_208() {
5636     if (jj_scan_token(IDENTIFIER)) return true;
5637     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5638     return false;
5639   }
5640
5641   static final private boolean jj_3R_203() {
5642     Token xsp;
5643     xsp = jj_scanpos;
5644     if (jj_3R_208()) {
5645     jj_scanpos = xsp;
5646     if (jj_3R_209()) {
5647     jj_scanpos = xsp;
5648     if (jj_3R_210()) return true;
5649     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5650     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5651     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5652     return false;
5653   }
5654
5655   static final private boolean jj_3R_110() {
5656     if (jj_scan_token(BIT_OR)) return true;
5657     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5658     if (jj_3R_109()) return true;
5659     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5660     return false;
5661   }
5662
5663   static final private boolean jj_3R_103() {
5664     if (jj_3R_109()) return true;
5665     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5666     Token xsp;
5667     while (true) {
5668       xsp = jj_scanpos;
5669       if (jj_3R_110()) { jj_scanpos = xsp; break; }
5670       if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5671     }
5672     return false;
5673   }
5674
5675   static final private boolean jj_3R_188() {
5676     if (jj_scan_token(ARRAY)) return true;
5677     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5678     if (jj_3R_198()) return true;
5679     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5680     return false;
5681   }
5682
5683   static final private boolean jj_3R_132() {
5684     if (jj_scan_token(IDENTIFIER)) return true;
5685     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5686     return false;
5687   }
5688
5689   static final private boolean jj_3R_106() {
5690     if (jj_scan_token(DOT)) return true;
5691     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5692     if (jj_3R_103()) return true;
5693     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5694     return false;
5695   }
5696
5697   static final private boolean jj_3R_131() {
5698     if (jj_scan_token(LBRACE)) return true;
5699     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5700     if (jj_3R_49()) return true;
5701     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5702     if (jj_scan_token(RBRACE)) return true;
5703     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5704     return false;
5705   }
5706
5707   static final private boolean jj_3R_97() {
5708     if (jj_3R_103()) return true;
5709     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5710     Token xsp;
5711     while (true) {
5712       xsp = jj_scanpos;
5713       if (jj_3R_106()) { jj_scanpos = xsp; break; }
5714       if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5715     }
5716     return false;
5717   }
5718
5719   static final private boolean jj_3R_204() {
5720     if (jj_3R_207()) return true;
5721     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5722     return false;
5723   }
5724
5725   static final private boolean jj_3R_122() {
5726     Token xsp;
5727     xsp = jj_scanpos;
5728     if (jj_3R_130()) {
5729     jj_scanpos = xsp;
5730     if (jj_3R_131()) {
5731     jj_scanpos = xsp;
5732     if (jj_3R_132()) return true;
5733     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5734     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5735     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5736     return false;
5737   }
5738
5739   static final private boolean jj_3R_130() {
5740     if (jj_scan_token(DOLLAR)) return true;
5741     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5742     if (jj_3R_122()) return true;
5743     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5744     return false;
5745   }
5746
5747   static final private boolean jj_3R_108() {
5748     if (jj_scan_token(_ANDL)) return true;
5749     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5750     return false;
5751   }
5752
5753   static final private boolean jj_3R_107() {
5754     if (jj_scan_token(AND_AND)) return true;
5755     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5756     return false;
5757   }
5758
5759   static final private boolean jj_3R_100() {
5760     Token xsp;
5761     xsp = jj_scanpos;
5762     if (jj_3R_107()) {
5763     jj_scanpos = xsp;
5764     if (jj_3R_108()) return true;
5765     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5766     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5767     if (jj_3R_97()) return true;
5768     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5769     return false;
5770   }
5771
5772   static final private boolean jj_3R_81() {
5773     if (jj_3R_97()) return true;
5774     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5775     Token xsp;
5776     while (true) {
5777       xsp = jj_scanpos;
5778       if (jj_3R_100()) { jj_scanpos = xsp; break; }
5779       if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5780     }
5781     return false;
5782   }
5783
5784   static final private boolean jj_3R_79() {
5785     if (jj_scan_token(HOOK)) return true;
5786     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5787     if (jj_3R_49()) return true;
5788     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5789     if (jj_scan_token(COLON)) return true;
5790     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5791     if (jj_3R_73()) return true;
5792     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5793     return false;
5794   }
5795
5796   static final private boolean jj_3R_195() {
5797     if (jj_scan_token(NEW)) return true;
5798     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5799     if (jj_3R_203()) return true;
5800     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5801     Token xsp;
5802     xsp = jj_scanpos;
5803     if (jj_3R_204()) jj_scanpos = xsp;
5804     else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5805     return false;
5806   }
5807
5808   static final private boolean jj_3R_68() {
5809     if (jj_scan_token(DOLLAR)) return true;
5810     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5811     if (jj_3R_122()) return true;
5812     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5813     return false;
5814   }
5815
5816   static final private boolean jj_3R_202() {
5817     if (jj_3R_207()) return true;
5818     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5819     return false;
5820   }
5821
5822   static final private boolean jj_3R_194() {
5823     if (jj_3R_116()) return true;
5824     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5825     Token xsp;
5826     xsp = jj_scanpos;
5827     if (jj_3R_202()) jj_scanpos = xsp;
5828     else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5829     return false;
5830   }
5831
5832   static final private boolean jj_3R_102() {
5833     if (jj_scan_token(_ORL)) return true;
5834     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5835     return false;
5836   }
5837
5838   static final private boolean jj_3R_101() {
5839     if (jj_scan_token(OR_OR)) return true;
5840     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5841     return false;
5842   }
5843
5844   static final private boolean jj_3R_83() {
5845     Token xsp;
5846     xsp = jj_scanpos;
5847     if (jj_3R_101()) {
5848     jj_scanpos = xsp;
5849     if (jj_3R_102()) return true;
5850     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5851     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5852     if (jj_3R_81()) return true;
5853     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5854     return false;
5855   }
5856
5857   static final private boolean jj_3R_201() {
5858     if (jj_3R_207()) return true;
5859     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5860     return false;
5861   }
5862
5863   static final private boolean jj_3R_76() {
5864     if (jj_3R_81()) return true;
5865     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5866     Token xsp;
5867     while (true) {
5868       xsp = jj_scanpos;
5869       if (jj_3R_83()) { jj_scanpos = xsp; break; }
5870       if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5871     }
5872     return false;
5873   }
5874
5875   static final private boolean jj_3_1() {
5876     if (jj_3R_40()) return true;
5877     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5878     return false;
5879   }
5880
5881   static final private boolean jj_3R_51() {
5882     if (jj_scan_token(COMMA)) return true;
5883     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5884     if (jj_3R_49()) return true;
5885     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5886     return false;
5887   }
5888
5889   static final private boolean jj_3R_200() {
5890     if (jj_scan_token(STATICCLASSACCESS)) return true;
5891     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5892     if (jj_3R_203()) return true;
5893     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5894     return false;
5895   }
5896
5897   static final private boolean jj_3R_45() {
5898     if (jj_3R_49()) return true;
5899     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5900     Token xsp;
5901     while (true) {
5902       xsp = jj_scanpos;
5903       if (jj_3R_51()) { jj_scanpos = xsp; break; }
5904       if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5905     }
5906     return false;
5907   }
5908
5909   static final private boolean jj_3R_116() {
5910     if (jj_3R_68()) return true;
5911     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5912     Token xsp;
5913     while (true) {
5914       xsp = jj_scanpos;
5915       if (jj_3_1()) { jj_scanpos = xsp; break; }
5916       if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5917     }
5918     return false;
5919   }
5920
5921   static final private boolean jj_3R_193() {
5922     if (jj_scan_token(IDENTIFIER)) return true;
5923     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5924     Token xsp;
5925     while (true) {
5926       xsp = jj_scanpos;
5927       if (jj_3R_200()) { jj_scanpos = xsp; break; }
5928       if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5929     }
5930     xsp = jj_scanpos;
5931     if (jj_3R_201()) jj_scanpos = xsp;
5932     else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5933     return false;
5934   }
5935
5936   static final private boolean jj_3R_187() {
5937     Token xsp;
5938     xsp = jj_scanpos;
5939     if (jj_3R_193()) {
5940     jj_scanpos = xsp;
5941     if (jj_3R_194()) {
5942     jj_scanpos = xsp;
5943     if (jj_3R_195()) return true;
5944     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5945     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5946     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5947     return false;
5948   }
5949
5950   static final private boolean jj_3R_73() {
5951     if (jj_3R_76()) return true;
5952     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5953     Token xsp;
5954     xsp = jj_scanpos;
5955     if (jj_3R_79()) jj_scanpos = xsp;
5956     else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5957     return false;
5958   }
5959
5960   static final private boolean jj_3R_178() {
5961     if (jj_3R_188()) return true;
5962     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5963     return false;
5964   }
5965
5966   static final private boolean jj_3R_186() {
5967     if (jj_scan_token(BIT_AND)) return true;
5968     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5969     return false;
5970   }
5971
5972   static final private boolean jj_3R_96() {
5973     if (jj_scan_token(TILDEEQUAL)) return true;
5974     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5975     return false;
5976   }
5977
5978   static final private boolean jj_3R_95() {
5979     if (jj_scan_token(DOTASSIGN)) return true;
5980     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5981     return false;
5982   }
5983
5984   static final private boolean jj_3R_173() {
5985     Token xsp;
5986     xsp = jj_scanpos;
5987     if (jj_3R_177()) {
5988     jj_scanpos = xsp;
5989     if (jj_3R_178()) return true;
5990     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5991     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5992     return false;
5993   }
5994
5995   static final private boolean jj_3R_177() {
5996     Token xsp;
5997     xsp = jj_scanpos;
5998     if (jj_3R_186()) jj_scanpos = xsp;
5999     else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6000     if (jj_3R_187()) return true;
6001     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6002     return false;
6003   }
6004
6005   static final private boolean jj_3_5() {
6006     if (jj_3R_45()) return true;
6007     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6008     return false;
6009   }
6010
6011   static final private boolean jj_3R_94() {
6012     if (jj_scan_token(ORASSIGN)) return true;
6013     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6014     return false;
6015   }
6016
6017   static final private boolean jj_3R_93() {
6018     if (jj_scan_token(XORASSIGN)) return true;
6019     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6020     return false;
6021   }
6022
6023   static final private boolean jj_3R_92() {
6024     if (jj_scan_token(ANDASSIGN)) return true;
6025     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6026     return false;
6027   }
6028
6029   static final private boolean jj_3R_91() {
6030     if (jj_scan_token(RSIGNEDSHIFTASSIGN)) return true;
6031     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6032     return false;
6033   }
6034
6035   static final private boolean jj_3R_90() {
6036     if (jj_scan_token(LSHIFTASSIGN)) return true;
6037     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6038     return false;
6039   }
6040
6041   static final private boolean jj_3R_89() {
6042     if (jj_scan_token(MINUSASSIGN)) return true;
6043     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6044     return false;
6045   }
6046
6047   static final private boolean jj_3R_88() {
6048     if (jj_scan_token(PLUSASSIGN)) return true;
6049     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6050     return false;
6051   }
6052
6053   static final private boolean jj_3R_87() {
6054     if (jj_scan_token(REMASSIGN)) return true;
6055     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6056     return false;
6057   }
6058
6059   static final private boolean jj_3R_86() {
6060     if (jj_scan_token(SLASHASSIGN)) return true;
6061     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6062     return false;
6063   }
6064
6065   static final private boolean jj_3R_85() {
6066     if (jj_scan_token(STARASSIGN)) return true;
6067     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6068     return false;
6069   }
6070
6071   static final private boolean jj_3R_84() {
6072     if (jj_scan_token(ASSIGN)) return true;
6073     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6074     return false;
6075   }
6076
6077   static final private boolean jj_3R_80() {
6078     Token xsp;
6079     xsp = jj_scanpos;
6080     if (jj_3R_84()) {
6081     jj_scanpos = xsp;
6082     if (jj_3R_85()) {
6083     jj_scanpos = xsp;
6084     if (jj_3R_86()) {
6085     jj_scanpos = xsp;
6086     if (jj_3R_87()) {
6087     jj_scanpos = xsp;
6088     if (jj_3R_88()) {
6089     jj_scanpos = xsp;
6090     if (jj_3R_89()) {
6091     jj_scanpos = xsp;
6092     if (jj_3R_90()) {
6093     jj_scanpos = xsp;
6094     if (jj_3R_91()) {
6095     jj_scanpos = xsp;
6096     if (jj_3R_92()) {
6097     jj_scanpos = xsp;
6098     if (jj_3R_93()) {
6099     jj_scanpos = xsp;
6100     if (jj_3R_94()) {
6101     jj_scanpos = xsp;
6102     if (jj_3R_95()) {
6103     jj_scanpos = xsp;
6104     if (jj_3R_96()) return true;
6105     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6106     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6107     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6108     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6109     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6110     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6111     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6112     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6113     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6114     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6115     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6116     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6117     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6118     return false;
6119   }
6120
6121   static final private boolean jj_3R_197() {
6122     if (jj_scan_token(MINUS_MINUS)) return true;
6123     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6124     return false;
6125   }
6126
6127   static final private boolean jj_3R_196() {
6128     if (jj_scan_token(PLUS_PLUS)) return true;
6129     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6130     return false;
6131   }
6132
6133   static final private boolean jj_3R_191() {
6134     Token xsp;
6135     xsp = jj_scanpos;
6136     if (jj_3R_196()) {
6137     jj_scanpos = xsp;
6138     if (jj_3R_197()) return true;
6139     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6140     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6141     return false;
6142   }
6143
6144   static final private boolean jj_3R_175() {
6145     if (jj_3R_173()) return true;
6146     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6147     Token xsp;
6148     xsp = jj_scanpos;
6149     if (jj_3R_191()) jj_scanpos = xsp;
6150     else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6151     return false;
6152   }
6153
6154   static final private boolean jj_3R_99() {
6155     if (jj_3R_105()) return true;
6156     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6157     return false;
6158   }
6159
6160   static final private boolean jj_3R_98() {
6161     if (jj_3R_104()) return true;
6162     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6163     return false;
6164   }
6165
6166   static final private boolean jj_3R_82() {
6167     Token xsp;
6168     xsp = jj_scanpos;
6169     if (jj_3R_98()) {
6170     jj_scanpos = xsp;
6171     if (jj_3R_99()) return true;
6172     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6173     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6174     return false;
6175   }
6176
6177   static final private boolean jj_3R_190() {
6178     if (jj_scan_token(ARRAY)) return true;
6179     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6180     return false;
6181   }
6182
6183   static final private boolean jj_3R_189() {
6184     if (jj_3R_50()) return true;
6185     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6186     return false;
6187   }
6188
6189   static final private boolean jj_3R_78() {
6190     if (jj_3R_82()) return true;
6191     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6192     return false;
6193   }
6194
6195   static final private boolean jj_3R_43() {
6196     if (jj_scan_token(ARRAY)) return true;
6197     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6198     return false;
6199   }
6200
6201   static final private boolean jj_3R_77() {
6202     if (jj_scan_token(BANG)) return true;
6203     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6204     if (jj_3R_74()) return true;
6205     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6206     return false;
6207   }
6208
6209   static final private boolean jj_3R_74() {
6210     Token xsp;
6211     xsp = jj_scanpos;
6212     if (jj_3R_77()) {
6213     jj_scanpos = xsp;
6214     if (jj_3R_78()) return true;
6215     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6216     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6217     return false;
6218   }
6219
6220   static final private boolean jj_3R_174() {
6221     if (jj_scan_token(LPAREN)) return true;
6222     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6223     Token xsp;
6224     xsp = jj_scanpos;
6225     if (jj_3R_189()) {
6226     jj_scanpos = xsp;
6227     if (jj_3R_190()) return true;
6228     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6229     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6230     if (jj_scan_token(RPAREN)) return true;
6231     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6232     if (jj_3R_144()) return true;
6233     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6234     return false;
6235   }
6236
6237   static final private boolean jj_3R_42() {
6238     if (jj_3R_50()) return true;
6239     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6240     return false;
6241   }
6242
6243   static final private boolean jj_3R_58() {
6244     if (jj_3R_74()) return true;
6245     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6246     return false;
6247   }
6248
6249   static final private boolean jj_3_3() {
6250     if (jj_scan_token(LPAREN)) return true;
6251     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6252     Token xsp;
6253     xsp = jj_scanpos;
6254     if (jj_3R_42()) {
6255     jj_scanpos = xsp;
6256     if (jj_3R_43()) return true;
6257     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6258     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6259     if (jj_scan_token(RPAREN)) return true;
6260     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6261     return false;
6262   }
6263
6264   static final private boolean jj_3R_172() {
6265     if (jj_scan_token(LPAREN)) return true;
6266     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6267     if (jj_3R_49()) return true;
6268     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6269     if (jj_scan_token(RPAREN)) return true;
6270     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6271     return false;
6272   }
6273
6274   static final private boolean jj_3R_171() {
6275     if (jj_3R_176()) return true;
6276     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6277     return false;
6278   }
6279
6280   static final private boolean jj_3R_170() {
6281     if (jj_3R_175()) return true;
6282     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6283     return false;
6284   }
6285
6286   static final private boolean jj_3R_166() {
6287     Token xsp;
6288     xsp = jj_scanpos;
6289     if (jj_3R_169()) {
6290     jj_scanpos = xsp;
6291     if (jj_3R_170()) {
6292     jj_scanpos = xsp;
6293     if (jj_3R_171()) {
6294     jj_scanpos = xsp;
6295     if (jj_3R_172()) return true;
6296     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6297     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6298     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6299     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6300     return false;
6301   }
6302
6303   static final private boolean jj_3R_169() {
6304     if (jj_3R_174()) return true;
6305     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6306     return false;
6307   }
6308
6309   static final private boolean jj_3R_44() {
6310     if (jj_3R_49()) return true;
6311     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6312     if (jj_scan_token(SEMICOLON)) return true;
6313     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6314     return false;
6315   }
6316
6317   static final private boolean jj_3R_168() {
6318     if (jj_scan_token(MINUS_MINUS)) return true;
6319     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6320     return false;
6321   }
6322
6323   static final private boolean jj_3R_167() {
6324     if (jj_scan_token(PLUS_PLUS)) return true;
6325     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6326     return false;
6327   }
6328
6329   static final private boolean jj_3R_75() {
6330     if (jj_3R_80()) return true;
6331     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6332     if (jj_3R_49()) return true;
6333     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6334     return false;
6335   }
6336
6337   static final private boolean jj_3R_165() {
6338     Token xsp;
6339     xsp = jj_scanpos;
6340     if (jj_3R_167()) {
6341     jj_scanpos = xsp;
6342     if (jj_3R_168()) return true;
6343     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6344     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6345     if (jj_3R_173()) return true;
6346     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6347     return false;
6348   }
6349
6350   static final private boolean jj_3R_49() {
6351     Token xsp;
6352     xsp = jj_scanpos;
6353     if (jj_3R_57()) {
6354     jj_scanpos = xsp;
6355     if (jj_3R_58()) return true;
6356     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6357     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6358     return false;
6359   }
6360
6361   static final private boolean jj_3R_57() {
6362     if (jj_3R_73()) return true;
6363     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6364     Token xsp;
6365     xsp = jj_scanpos;
6366     if (jj_3R_75()) jj_scanpos = xsp;
6367     else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6368     return false;
6369   }
6370
6371   static final private boolean jj_3R_67() {
6372     if (jj_scan_token(OBJECT)) return true;
6373     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6374     return false;
6375   }
6376
6377   static final private boolean jj_3R_161() {
6378     if (jj_3R_166()) return true;
6379     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6380     return false;
6381   }
6382
6383   static final private boolean jj_3R_66() {
6384     if (jj_scan_token(INTEGER)) return true;
6385     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6386     return false;
6387   }
6388
6389   static final private boolean jj_3R_65() {
6390     if (jj_scan_token(INT)) return true;
6391     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6392     return false;
6393   }
6394
6395   static final private boolean jj_3R_64() {
6396     if (jj_scan_token(FLOAT)) return true;
6397     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6398     return false;
6399   }
6400
6401   static final private boolean jj_3R_160() {
6402     if (jj_3R_165()) return true;
6403     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6404     return false;
6405   }
6406
6407   static final private boolean jj_3R_63() {
6408     if (jj_scan_token(DOUBLE)) return true;
6409     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6410     return false;
6411   }
6412
6413   static final private boolean jj_3R_62() {
6414     if (jj_scan_token(REAL)) return true;
6415     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6416     return false;
6417   }
6418
6419   static final private boolean jj_3R_61() {
6420     if (jj_scan_token(BOOLEAN)) return true;
6421     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6422     return false;
6423   }
6424
6425   static final private boolean jj_3R_60() {
6426     if (jj_scan_token(BOOL)) return true;
6427     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6428     return false;
6429   }
6430
6431   static final private boolean jj_3R_159() {
6432     if (jj_scan_token(MINUS)) return true;
6433     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6434     if (jj_3R_148()) return true;
6435     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6436     return false;
6437   }
6438
6439   static final private boolean jj_3R_50() {
6440     Token xsp;
6441     xsp = jj_scanpos;
6442     if (jj_3R_59()) {
6443     jj_scanpos = xsp;
6444     if (jj_3R_60()) {
6445     jj_scanpos = xsp;
6446     if (jj_3R_61()) {
6447     jj_scanpos = xsp;
6448     if (jj_3R_62()) {
6449     jj_scanpos = xsp;
6450     if (jj_3R_63()) {
6451     jj_scanpos = xsp;
6452     if (jj_3R_64()) {
6453     jj_scanpos = xsp;
6454     if (jj_3R_65()) {
6455     jj_scanpos = xsp;
6456     if (jj_3R_66()) {
6457     jj_scanpos = xsp;
6458     if (jj_3R_67()) return true;
6459     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6460     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6461     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6462     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6463     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6464     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6465     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6466     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6467     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6468     return false;
6469   }
6470
6471   static final private boolean jj_3R_59() {
6472     if (jj_scan_token(STRING)) return true;
6473     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6474     return false;
6475   }
6476
6477   static final private boolean jj_3R_156() {
6478     Token xsp;
6479     xsp = jj_scanpos;
6480     if (jj_3R_158()) {
6481     jj_scanpos = xsp;
6482     if (jj_3R_159()) {
6483     jj_scanpos = xsp;
6484     if (jj_3R_160()) {
6485     jj_scanpos = xsp;
6486     if (jj_3R_161()) return true;
6487     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6488     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6489     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6490     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6491     return false;
6492   }
6493
6494   static final private boolean jj_3R_158() {
6495     if (jj_scan_token(PLUS)) return true;
6496     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6497     if (jj_3R_148()) return true;
6498     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6499     return false;
6500   }
6501
6502   static final private boolean jj_3_4() {
6503     if (jj_3R_44()) return true;
6504     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6505     return false;
6506   }
6507
6508   static final private boolean jj_3R_164() {
6509     if (jj_3R_156()) return true;
6510     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6511     return false;
6512   }
6513
6514   static final private boolean jj_3R_163() {
6515     if (jj_scan_token(BANG)) return true;
6516     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6517     if (jj_3R_157()) return true;
6518     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6519     return false;
6520   }
6521
6522   static final private boolean jj_3R_157() {
6523     Token xsp;
6524     xsp = jj_scanpos;
6525     if (jj_3R_162()) {
6526     jj_scanpos = xsp;
6527     if (jj_3R_163()) {
6528     jj_scanpos = xsp;
6529     if (jj_3R_164()) return true;
6530     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6531     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6532     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6533     return false;
6534   }
6535
6536   static final private boolean jj_3R_162() {
6537     if (jj_scan_token(AT)) return true;
6538     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6539     if (jj_3R_157()) return true;
6540     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6541     return false;
6542   }
6543
6544   static final private boolean jj_3R_155() {
6545     if (jj_3R_156()) return true;
6546     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6547     return false;
6548   }
6549
6550   static final private boolean jj_3R_216() {
6551     if (jj_scan_token(COMMA)) return true;
6552     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6553     if (jj_3R_49()) return true;
6554     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6555     return false;
6556   }
6557
6558   static final private boolean jj_3R_154() {
6559     if (jj_scan_token(BANG)) return true;
6560     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6561     if (jj_3R_157()) return true;
6562     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6563     return false;
6564   }
6565
6566   static final private boolean jj_3R_215() {
6567     if (jj_3R_49()) return true;
6568     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6569     Token xsp;
6570     while (true) {
6571       xsp = jj_scanpos;
6572       if (jj_3R_216()) { jj_scanpos = xsp; break; }
6573       if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6574     }
6575     return false;
6576   }
6577
6578   static final private boolean jj_3R_153() {
6579     if (jj_scan_token(TILDE)) return true;
6580     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6581     if (jj_3R_148()) return true;
6582     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6583     return false;
6584   }
6585
6586   static final private boolean jj_3R_148() {
6587     Token xsp;
6588     xsp = jj_scanpos;
6589     if (jj_3R_152()) {
6590     jj_scanpos = xsp;
6591     if (jj_3R_153()) {
6592     jj_scanpos = xsp;
6593     if (jj_3R_154()) {
6594     jj_scanpos = xsp;
6595     if (jj_3R_155()) return true;
6596     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6597     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6598     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6599     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6600     return false;
6601   }
6602
6603   static final private boolean jj_3R_152() {
6604     if (jj_scan_token(AT)) return true;
6605     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6606     if (jj_3R_148()) return true;
6607     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6608     return false;
6609   }
6610
6611   static final private boolean jj_3R_213() {
6612     if (jj_3R_215()) return true;
6613     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6614     return false;
6615   }
6616
6617   static final private boolean jj_3R_144() {
6618     if (jj_3R_148()) return true;
6619     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6620     return false;
6621   }
6622
6623   static final private boolean jj_3R_151() {
6624     if (jj_scan_token(REMAINDER)) return true;
6625     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6626     return false;
6627   }
6628
6629   static final private boolean jj_3R_150() {
6630     if (jj_scan_token(SLASH)) return true;
6631     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6632     return false;
6633   }
6634
6635   static final private boolean jj_3R_149() {
6636     if (jj_scan_token(STAR)) return true;
6637     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6638     return false;
6639   }
6640
6641   static final private boolean jj_3R_207() {
6642     if (jj_scan_token(LPAREN)) return true;
6643     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6644     Token xsp;
6645     xsp = jj_scanpos;
6646     if (jj_3R_213()) jj_scanpos = xsp;
6647     else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6648     if (jj_scan_token(RPAREN)) return true;
6649     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6650     return false;
6651   }
6652
6653   static final private boolean jj_3R_145() {
6654     Token xsp;
6655     xsp = jj_scanpos;
6656     if (jj_3R_149()) {
6657     jj_scanpos = xsp;
6658     if (jj_3R_150()) {
6659     jj_scanpos = xsp;
6660     if (jj_3R_151()) return true;
6661     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6662     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6663     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6664     if (jj_3R_144()) return true;
6665     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6666     return false;
6667   }
6668
6669   static final private boolean jj_3R_139() {
6670     if (jj_3R_144()) return true;
6671     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6672     Token xsp;
6673     while (true) {
6674       xsp = jj_scanpos;
6675       if (jj_3R_145()) { jj_scanpos = xsp; break; }
6676       if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6677     }
6678     return false;
6679   }
6680
6681   static final private boolean jj_3R_212() {
6682     if (jj_scan_token(LBRACE1)) return true;
6683     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6684     if (jj_scan_token(ID)) return true;
6685     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6686     if (jj_scan_token(RBRACE1)) return true;
6687     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6688     return false;
6689   }
6690
6691   static final private boolean jj_3R_147() {
6692     if (jj_scan_token(MINUS)) return true;
6693     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6694     return false;
6695   }
6696
6697   static final private boolean jj_3R_211() {
6698     if (jj_scan_token(IDENTIFIER)) return true;
6699     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6700     return false;
6701   }
6702
6703   static final private boolean jj_3R_146() {
6704     if (jj_scan_token(PLUS)) return true;
6705     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6706     return false;
6707   }
6708
6709   static final private boolean jj_3R_140() {
6710     Token xsp;
6711     xsp = jj_scanpos;
6712     if (jj_3R_146()) {
6713     jj_scanpos = xsp;
6714     if (jj_3R_147()) return true;
6715     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6716     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6717     if (jj_3R_139()) return true;
6718     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6719     return false;
6720   }
6721
6722   static final private boolean jj_3R_199() {
6723     if (jj_scan_token(DOLLARS)) return true;
6724     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6725     Token xsp;
6726     xsp = jj_scanpos;
6727     if (jj_3R_211()) {
6728     jj_scanpos = xsp;
6729     if (jj_3R_212()) return true;
6730     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6731     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6732     return false;
6733   }
6734
6735   static final private boolean jj_3R_133() {
6736     if (jj_3R_139()) return true;
6737     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6738     Token xsp;
6739     while (true) {
6740       xsp = jj_scanpos;
6741       if (jj_3R_140()) { jj_scanpos = xsp; break; }
6742       if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6743     }
6744     return false;
6745   }
6746
6747   static final private boolean jj_3R_192() {
6748     if (jj_scan_token(DOUBLEQUOTE)) return true;
6749     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6750     Token xsp;
6751     while (true) {
6752       xsp = jj_scanpos;
6753       if (jj_3R_199()) { jj_scanpos = xsp; break; }
6754       if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6755     }
6756     if (jj_scan_token(DOUBLEQUOTE2)) return true;
6757     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6758     return false;
6759   }
6760
6761   static final private boolean jj_3R_113() {
6762     if (jj_scan_token(ASSIGN)) return true;
6763     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6764     if (jj_3R_49()) return true;
6765     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6766     return false;
6767   }
6768
6769   static final private boolean jj_3R_143() {
6770     if (jj_scan_token(RUNSIGNEDSHIFT)) return true;
6771     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6772     return false;
6773   }
6774
6775   static final private boolean jj_3R_142() {
6776     if (jj_scan_token(RSIGNEDSHIFT)) return true;
6777     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6778     return false;
6779   }
6780
6781   static final private boolean jj_3R_141() {
6782     if (jj_scan_token(LSHIFT)) return true;
6783     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6784     return false;
6785   }
6786
6787   static final private boolean jj_3R_185() {
6788     if (jj_3R_192()) return true;
6789     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6790     return false;
6791   }
6792
6793   static final private boolean jj_3R_184() {
6794     if (jj_scan_token(NULL)) return true;
6795     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6796     return false;
6797   }
6798
6799   static final private boolean jj_3R_134() {
6800     Token xsp;
6801     xsp = jj_scanpos;
6802     if (jj_3R_141()) {
6803     jj_scanpos = xsp;
6804     if (jj_3R_142()) {
6805     jj_scanpos = xsp;
6806     if (jj_3R_143()) return true;
6807     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6808     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6809     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6810     if (jj_3R_133()) return true;
6811     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6812     return false;
6813   }
6814
6815   static final private boolean jj_3R_183() {
6816     if (jj_scan_token(FALSE)) return true;
6817     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6818     return false;
6819   }
6820
6821   static final private boolean jj_3R_182() {
6822     if (jj_scan_token(TRUE)) return true;
6823     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6824     return false;
6825   }
6826
6827   static final private boolean jj_3R_123() {
6828     if (jj_3R_133()) return true;
6829     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6830     Token xsp;
6831     while (true) {
6832       xsp = jj_scanpos;
6833       if (jj_3R_134()) { jj_scanpos = xsp; break; }
6834       if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6835     }
6836     return false;
6837   }
6838
6839   static final private boolean jj_3R_181() {
6840     if (jj_scan_token(STRING_LITERAL)) return true;
6841     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6842     return false;
6843   }
6844
6845   static final private boolean jj_3R_180() {
6846     if (jj_scan_token(FLOATING_POINT_LITERAL)) return true;
6847     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6848     return false;
6849   }
6850
6851   static final private boolean jj_3R_117() {
6852     if (jj_3R_116()) return true;
6853     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6854     return false;
6855   }
6856
6857   static final private boolean jj_3R_179() {
6858     if (jj_scan_token(INTEGER_LITERAL)) return true;
6859     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6860     return false;
6861   }
6862
6863   static final private boolean jj_3R_176() {
6864     Token xsp;
6865     xsp = jj_scanpos;
6866     if (jj_3R_179()) {
6867     jj_scanpos = xsp;
6868     if (jj_3R_180()) {
6869     jj_scanpos = xsp;
6870     if (jj_3R_181()) {
6871     jj_scanpos = xsp;
6872     if (jj_3R_182()) {
6873     jj_scanpos = xsp;
6874     if (jj_3R_183()) {
6875     jj_scanpos = xsp;
6876     if (jj_3R_184()) {
6877     jj_scanpos = xsp;
6878     if (jj_3R_185()) return true;
6879     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6880     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6881     } else 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     return false;
6887   }
6888
6889   static final private boolean jj_3R_138() {
6890     if (jj_scan_token(GE)) return true;
6891     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6892     return false;
6893   }
6894
6895   static final private boolean jj_3R_137() {
6896     if (jj_scan_token(LE)) return true;
6897     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6898     return false;
6899   }
6900
6901   static final private boolean jj_3R_136() {
6902     if (jj_scan_token(GT)) return true;
6903     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6904     return false;
6905   }
6906
6907   static final private boolean jj_3R_112() {
6908     if (jj_scan_token(COMMA)) return true;
6909     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6910     Token xsp;
6911     xsp = jj_scanpos;
6912     if (jj_3R_117()) jj_scanpos = xsp;
6913     else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6914     return false;
6915   }
6916
6917   static final private boolean jj_3R_135() {
6918     if (jj_scan_token(LT)) return true;
6919     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6920     return false;
6921   }
6922
6923   static final private boolean jj_3R_124() {
6924     Token xsp;
6925     xsp = jj_scanpos;
6926     if (jj_3R_135()) {
6927     jj_scanpos = xsp;
6928     if (jj_3R_136()) {
6929     jj_scanpos = xsp;
6930     if (jj_3R_137()) {
6931     jj_scanpos = xsp;
6932     if (jj_3R_138()) return true;
6933     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6934     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6935     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6936     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6937     if (jj_3R_123()) return true;
6938     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6939     return false;
6940   }
6941
6942   static final private boolean jj_3R_120() {
6943     if (jj_3R_123()) return true;
6944     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6945     Token xsp;
6946     while (true) {
6947       xsp = jj_scanpos;
6948       if (jj_3R_124()) { jj_scanpos = xsp; break; }
6949       if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6950     }
6951     return false;
6952   }
6953
6954   static final private boolean jj_3R_111() {
6955     if (jj_3R_116()) return true;
6956     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6957     return false;
6958   }
6959
6960   static final private boolean jj_3R_72() {
6961     if (jj_3R_50()) return true;
6962     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6963     return false;
6964   }
6965
6966   static final private boolean jj_3R_71() {
6967     if (jj_3R_49()) return true;
6968     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6969     return false;
6970   }
6971
6972   static final private boolean jj_3R_56() {
6973     Token xsp;
6974     xsp = jj_scanpos;
6975     if (jj_3R_71()) {
6976     jj_scanpos = xsp;
6977     if (jj_3R_72()) return true;
6978     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6979     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6980     return false;
6981   }
6982
6983   static final private boolean jj_3R_48() {
6984     if (jj_scan_token(LBRACE)) return true;
6985     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6986     Token xsp;
6987     xsp = jj_scanpos;
6988     if (jj_3R_56()) jj_scanpos = xsp;
6989     else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6990     if (jj_scan_token(RBRACE)) return true;
6991     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6992     return false;
6993   }
6994
6995   static final private boolean jj_3R_104() {
6996     if (jj_scan_token(LIST)) return true;
6997     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6998     if (jj_scan_token(LPAREN)) return true;
6999     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7000     Token xsp;
7001     xsp = jj_scanpos;
7002     if (jj_3R_111()) jj_scanpos = xsp;
7003     else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7004     while (true) {
7005       xsp = jj_scanpos;
7006       if (jj_3R_112()) { jj_scanpos = xsp; break; }
7007       if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7008     }
7009     if (jj_scan_token(RPAREN)) return true;
7010     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7011     xsp = jj_scanpos;
7012     if (jj_3R_113()) jj_scanpos = xsp;
7013     else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7014     return false;
7015   }
7016
7017   static final private boolean jj_3R_206() {
7018     if (jj_scan_token(COMMA)) return true;
7019     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7020     return false;
7021   }
7022
7023   static final private boolean jj_3R_70() {
7024     if (jj_3R_50()) return true;
7025     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7026     return false;
7027   }
7028
7029   static final private boolean jj_3_2() {
7030     if (jj_scan_token(COMMA)) return true;
7031     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7032     if (jj_3R_41()) return true;
7033     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7034     return false;
7035   }
7036
7037   static final private boolean jj_3R_55() {
7038     Token xsp;
7039     xsp = jj_scanpos;
7040     if (jj_3R_69()) {
7041     jj_scanpos = xsp;
7042     if (jj_3R_70()) return true;
7043     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7044     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7045     return false;
7046   }
7047
7048   static final private boolean jj_3R_69() {
7049     if (jj_3R_49()) return true;
7050     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7051     return false;
7052   }
7053
7054   static final private boolean jj_3R_205() {
7055     if (jj_3R_41()) return true;
7056     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7057     Token xsp;
7058     while (true) {
7059       xsp = jj_scanpos;
7060       if (jj_3_2()) { jj_scanpos = xsp; break; }
7061       if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7062     }
7063     return false;
7064   }
7065
7066   static final private boolean jj_3R_47() {
7067     if (jj_scan_token(LBRACKET)) return true;
7068     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7069     Token xsp;
7070     xsp = jj_scanpos;
7071     if (jj_3R_55()) jj_scanpos = xsp;
7072     else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7073     if (jj_scan_token(RBRACKET)) return true;
7074     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7075     return false;
7076   }
7077
7078   static final private boolean jj_3R_129() {
7079     if (jj_scan_token(TRIPLEEQUAL)) return true;
7080     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7081     return false;
7082   }
7083
7084   static final private boolean jj_3R_128() {
7085     if (jj_scan_token(BANGDOUBLEEQUAL)) return true;
7086     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7087     return false;
7088   }
7089
7090   static final private boolean jj_3R_127() {
7091     if (jj_scan_token(NOT_EQUAL)) return true;
7092     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7093     return false;
7094   }
7095
7096   static final private boolean jj_3R_126() {
7097     if (jj_scan_token(DIF)) return true;
7098     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7099     return false;
7100   }
7101
7102   static final private boolean jj_3R_105() {
7103     if (jj_scan_token(PRINT)) return true;
7104     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7105     if (jj_3R_49()) return true;
7106     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7107     return false;
7108   }
7109
7110   static final private boolean jj_3R_198() {
7111     if (jj_scan_token(LPAREN)) return true;
7112     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7113     Token xsp;
7114     xsp = jj_scanpos;
7115     if (jj_3R_205()) jj_scanpos = xsp;
7116     else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7117     xsp = jj_scanpos;
7118     if (jj_3R_206()) jj_scanpos = xsp;
7119     else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7120     if (jj_scan_token(RPAREN)) return true;
7121     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7122     return false;
7123   }
7124
7125   static final private boolean jj_3R_125() {
7126     if (jj_scan_token(EQUAL_EQUAL)) return true;
7127     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7128     return false;
7129   }
7130
7131   static final private boolean jj_3R_54() {
7132     if (jj_3R_68()) return true;
7133     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7134     return false;
7135   }
7136
7137   static final private boolean jj_3R_121() {
7138     Token xsp;
7139     xsp = jj_scanpos;
7140     if (jj_3R_125()) {
7141     jj_scanpos = xsp;
7142     if (jj_3R_126()) {
7143     jj_scanpos = xsp;
7144     if (jj_3R_127()) {
7145     jj_scanpos = xsp;
7146     if (jj_3R_128()) {
7147     jj_scanpos = xsp;
7148     if (jj_3R_129()) return true;
7149     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7150     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7151     } else 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     if (jj_3R_120()) return true;
7155     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7156     return false;
7157   }
7158
7159   static final private boolean jj_3R_53() {
7160     if (jj_scan_token(IDENTIFIER)) return true;
7161     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7162     return false;
7163   }
7164
7165   static final private boolean jj_3R_118() {
7166     if (jj_3R_120()) return true;
7167     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7168     Token xsp;
7169     while (true) {
7170       xsp = jj_scanpos;
7171       if (jj_3R_121()) { jj_scanpos = xsp; break; }
7172       if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7173     }
7174     return false;
7175   }
7176
7177   static final private boolean jj_3R_214() {
7178     if (jj_scan_token(ARRAYASSIGN)) return true;
7179     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7180     if (jj_3R_49()) return true;
7181     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7182     return false;
7183   }
7184
7185   static final private boolean jj_3R_52() {
7186     if (jj_scan_token(LBRACE)) return true;
7187     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7188     if (jj_3R_49()) return true;
7189     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7190     if (jj_scan_token(RBRACE)) return true;
7191     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7192     return false;
7193   }
7194
7195   static final private boolean jj_3R_41() {
7196     if (jj_3R_49()) return true;
7197     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7198     Token xsp;
7199     xsp = jj_scanpos;
7200     if (jj_3R_214()) jj_scanpos = xsp;
7201     else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7202     return false;
7203   }
7204
7205   static final private boolean jj_3R_119() {
7206     if (jj_scan_token(BIT_AND)) return true;
7207     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7208     if (jj_3R_118()) return true;
7209     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7210     return false;
7211   }
7212
7213   static final private boolean jj_3R_46() {
7214     if (jj_scan_token(CLASSACCESS)) return true;
7215     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7216     Token xsp;
7217     xsp = jj_scanpos;
7218     if (jj_3R_52()) {
7219     jj_scanpos = xsp;
7220     if (jj_3R_53()) {
7221     jj_scanpos = xsp;
7222     if (jj_3R_54()) return true;
7223     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7224     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7225     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7226     return false;
7227   }
7228
7229   static final private boolean jj_3R_40() {
7230     Token xsp;
7231     xsp = jj_scanpos;
7232     if (jj_3R_46()) {
7233     jj_scanpos = xsp;
7234     if (jj_3R_47()) {
7235     jj_scanpos = xsp;
7236     if (jj_3R_48()) return true;
7237     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7238     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7239     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7240     return false;
7241   }
7242
7243   static final private boolean jj_3R_114() {
7244     if (jj_3R_118()) return true;
7245     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7246     Token xsp;
7247     while (true) {
7248       xsp = jj_scanpos;
7249       if (jj_3R_119()) { jj_scanpos = xsp; break; }
7250       if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7251     }
7252     return false;
7253   }
7254
7255   static final private boolean jj_3R_115() {
7256     if (jj_scan_token(XOR)) return true;
7257     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7258     if (jj_3R_114()) return true;
7259     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7260     return false;
7261   }
7262
7263   static private boolean jj_initialized_once = false;
7264   static public PHPParserTokenManager token_source;
7265   static SimpleCharStream jj_input_stream;
7266   static public Token token, jj_nt;
7267   static private int jj_ntk;
7268   static private Token jj_scanpos, jj_lastpos;
7269   static private int jj_la;
7270   static public boolean lookingAhead = false;
7271   static private boolean jj_semLA;
7272   static private int jj_gen;
7273   static final private int[] jj_la1 = new int[128];
7274   static private int[] jj_la1_0;
7275   static private int[] jj_la1_1;
7276   static private int[] jj_la1_2;
7277   static private int[] jj_la1_3;
7278   static private int[] jj_la1_4;
7279   static {
7280       jj_la1_0();
7281       jj_la1_1();
7282       jj_la1_2();
7283       jj_la1_3();
7284       jj_la1_4();
7285    }
7286    private static void jj_la1_0() {
7287       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,};
7288    }
7289    private static void jj_la1_1() {
7290       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,};
7291    }
7292    private static void jj_la1_2() {
7293       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,};
7294    }
7295    private static void jj_la1_3() {
7296       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,};
7297    }
7298    private static void jj_la1_4() {
7299       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,};
7300    }
7301   static final private JJCalls[] jj_2_rtns = new JJCalls[5];
7302   static private boolean jj_rescan = false;
7303   static private int jj_gc = 0;
7304
7305   public PHPParser(java.io.InputStream stream) {
7306     if (jj_initialized_once) {
7307       System.out.println("ERROR: Second call to constructor of static parser.  You must");
7308       System.out.println("       either use ReInit() or set the JavaCC option STATIC to false");
7309       System.out.println("       during parser generation.");
7310       throw new Error();
7311     }
7312     jj_initialized_once = true;
7313     jj_input_stream = new SimpleCharStream(stream, 1, 1);
7314     token_source = new PHPParserTokenManager(jj_input_stream);
7315     token = new Token();
7316     jj_ntk = -1;
7317     jj_gen = 0;
7318     for (int i = 0; i < 128; i++) jj_la1[i] = -1;
7319     for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
7320   }
7321
7322   static public void ReInit(java.io.InputStream stream) {
7323     jj_input_stream.ReInit(stream, 1, 1);
7324     token_source.ReInit(jj_input_stream);
7325     token = new Token();
7326     jj_ntk = -1;
7327     jj_gen = 0;
7328     for (int i = 0; i < 128; i++) jj_la1[i] = -1;
7329     for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
7330   }
7331
7332   public PHPParser(java.io.Reader stream) {
7333     if (jj_initialized_once) {
7334       System.out.println("ERROR: Second call to constructor of static parser.  You must");
7335       System.out.println("       either use ReInit() or set the JavaCC option STATIC to false");
7336       System.out.println("       during parser generation.");
7337       throw new Error();
7338     }
7339     jj_initialized_once = true;
7340     jj_input_stream = new SimpleCharStream(stream, 1, 1);
7341     token_source = new PHPParserTokenManager(jj_input_stream);
7342     token = new Token();
7343     jj_ntk = -1;
7344     jj_gen = 0;
7345     for (int i = 0; i < 128; i++) jj_la1[i] = -1;
7346     for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
7347   }
7348
7349   static public void ReInit(java.io.Reader stream) {
7350     jj_input_stream.ReInit(stream, 1, 1);
7351     token_source.ReInit(jj_input_stream);
7352     token = new Token();
7353     jj_ntk = -1;
7354     jj_gen = 0;
7355     for (int i = 0; i < 128; i++) jj_la1[i] = -1;
7356     for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
7357   }
7358
7359   public PHPParser(PHPParserTokenManager tm) {
7360     if (jj_initialized_once) {
7361       System.out.println("ERROR: Second call to constructor of static parser.  You must");
7362       System.out.println("       either use ReInit() or set the JavaCC option STATIC to false");
7363       System.out.println("       during parser generation.");
7364       throw new Error();
7365     }
7366     jj_initialized_once = true;
7367     token_source = tm;
7368     token = new Token();
7369     jj_ntk = -1;
7370     jj_gen = 0;
7371     for (int i = 0; i < 128; i++) jj_la1[i] = -1;
7372     for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
7373   }
7374
7375   public void ReInit(PHPParserTokenManager tm) {
7376     token_source = tm;
7377     token = new Token();
7378     jj_ntk = -1;
7379     jj_gen = 0;
7380     for (int i = 0; i < 128; i++) jj_la1[i] = -1;
7381     for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
7382   }
7383
7384   static final private Token jj_consume_token(int kind) throws ParseException {
7385     Token oldToken;
7386     if ((oldToken = token).next != null) token = token.next;
7387     else token = token.next = token_source.getNextToken();
7388     jj_ntk = -1;
7389     if (token.kind == kind) {
7390       jj_gen++;
7391       if (++jj_gc > 100) {
7392         jj_gc = 0;
7393         for (int i = 0; i < jj_2_rtns.length; i++) {
7394           JJCalls c = jj_2_rtns[i];
7395           while (c != null) {
7396             if (c.gen < jj_gen) c.first = null;
7397             c = c.next;
7398           }
7399         }
7400       }
7401       return token;
7402     }
7403     token = oldToken;
7404     jj_kind = kind;
7405     throw generateParseException();
7406   }
7407
7408   static final private boolean jj_scan_token(int kind) {
7409     if (jj_scanpos == jj_lastpos) {
7410       jj_la--;
7411       if (jj_scanpos.next == null) {
7412         jj_lastpos = jj_scanpos = jj_scanpos.next = token_source.getNextToken();
7413       } else {
7414         jj_lastpos = jj_scanpos = jj_scanpos.next;
7415       }
7416     } else {
7417       jj_scanpos = jj_scanpos.next;
7418     }
7419     if (jj_rescan) {
7420       int i = 0; Token tok = token;
7421       while (tok != null && tok != jj_scanpos) { i++; tok = tok.next; }
7422       if (tok != null) jj_add_error_token(kind, i);
7423     }
7424     return (jj_scanpos.kind != kind);
7425   }
7426
7427   static final public Token getNextToken() {
7428     if (token.next != null) token = token.next;
7429     else token = token.next = token_source.getNextToken();
7430     jj_ntk = -1;
7431     jj_gen++;
7432     return token;
7433   }
7434
7435   static final public Token getToken(int index) {
7436     Token t = lookingAhead ? jj_scanpos : token;
7437     for (int i = 0; i < index; i++) {
7438       if (t.next != null) t = t.next;
7439       else t = t.next = token_source.getNextToken();
7440     }
7441     return t;
7442   }
7443
7444   static final private int jj_ntk() {
7445     if ((jj_nt=token.next) == null)
7446       return (jj_ntk = (token.next=token_source.getNextToken()).kind);
7447     else
7448       return (jj_ntk = jj_nt.kind);
7449   }
7450
7451   static private java.util.Vector jj_expentries = new java.util.Vector();
7452   static private int[] jj_expentry;
7453   static private int jj_kind = -1;
7454   static private int[] jj_lasttokens = new int[100];
7455   static private int jj_endpos;
7456
7457   static private void jj_add_error_token(int kind, int pos) {
7458     if (pos >= 100) return;
7459     if (pos == jj_endpos + 1) {
7460       jj_lasttokens[jj_endpos++] = kind;
7461     } else if (jj_endpos != 0) {
7462       jj_expentry = new int[jj_endpos];
7463       for (int i = 0; i < jj_endpos; i++) {
7464         jj_expentry[i] = jj_lasttokens[i];
7465       }
7466       boolean exists = false;
7467       for (java.util.Enumeration enum = jj_expentries.elements(); enum.hasMoreElements();) {
7468         int[] oldentry = (int[])(enum.nextElement());
7469         if (oldentry.length == jj_expentry.length) {
7470           exists = true;
7471           for (int i = 0; i < jj_expentry.length; i++) {
7472             if (oldentry[i] != jj_expentry[i]) {
7473               exists = false;
7474               break;
7475             }
7476           }
7477           if (exists) break;
7478         }
7479       }
7480       if (!exists) jj_expentries.addElement(jj_expentry);
7481       if (pos != 0) jj_lasttokens[(jj_endpos = pos) - 1] = kind;
7482     }
7483   }
7484
7485   static public ParseException generateParseException() {
7486     jj_expentries.removeAllElements();
7487     boolean[] la1tokens = new boolean[160];
7488     for (int i = 0; i < 160; i++) {
7489       la1tokens[i] = false;
7490     }
7491     if (jj_kind >= 0) {
7492       la1tokens[jj_kind] = true;
7493       jj_kind = -1;
7494     }
7495     for (int i = 0; i < 128; i++) {
7496       if (jj_la1[i] == jj_gen) {
7497         for (int j = 0; j < 32; j++) {
7498           if ((jj_la1_0[i] & (1<<j)) != 0) {
7499             la1tokens[j] = true;
7500           }
7501           if ((jj_la1_1[i] & (1<<j)) != 0) {
7502             la1tokens[32+j] = true;
7503           }
7504           if ((jj_la1_2[i] & (1<<j)) != 0) {
7505             la1tokens[64+j] = true;
7506           }
7507           if ((jj_la1_3[i] & (1<<j)) != 0) {
7508             la1tokens[96+j] = true;
7509           }
7510           if ((jj_la1_4[i] & (1<<j)) != 0) {
7511             la1tokens[128+j] = true;
7512           }
7513         }
7514       }
7515     }
7516     for (int i = 0; i < 160; i++) {
7517       if (la1tokens[i]) {
7518         jj_expentry = new int[1];
7519         jj_expentry[0] = i;
7520         jj_expentries.addElement(jj_expentry);
7521       }
7522     }
7523     jj_endpos = 0;
7524     jj_rescan_token();
7525     jj_add_error_token(0, 0);
7526     int[][] exptokseq = new int[jj_expentries.size()][];
7527     for (int i = 0; i < jj_expentries.size(); i++) {
7528       exptokseq[i] = (int[])jj_expentries.elementAt(i);
7529     }
7530     return new ParseException(token, exptokseq, tokenImage);
7531   }
7532
7533   static final public void enable_tracing() {
7534   }
7535
7536   static final public void disable_tracing() {
7537   }
7538
7539   static final private void jj_rescan_token() {
7540     jj_rescan = true;
7541     for (int i = 0; i < 5; i++) {
7542       JJCalls p = jj_2_rtns[i];
7543       do {
7544         if (p.gen > jj_gen) {
7545           jj_la = p.arg; jj_lastpos = jj_scanpos = p.first;
7546           switch (i) {
7547             case 0: jj_3_1(); break;
7548             case 1: jj_3_2(); break;
7549             case 2: jj_3_3(); break;
7550             case 3: jj_3_4(); break;
7551             case 4: jj_3_5(); break;
7552           }
7553         }
7554         p = p.next;
7555       } while (p != null);
7556     }
7557     jj_rescan = false;
7558   }
7559
7560   static final private void jj_save(int index, int xla) {
7561     JJCalls p = jj_2_rtns[index];
7562     while (p.gen > jj_gen) {
7563       if (p.next == null) { p = p.next = new JJCalls(); break; }
7564       p = p.next;
7565     }
7566     p.gen = jj_gen + xla - jj_la; p.first = token; p.arg = xla;
7567   }
7568
7569   static final class JJCalls {
7570     int gen;
7571     Token first;
7572     int arg;
7573     JJCalls next;
7574   }
7575
7576 }