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

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