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 String html = SimpleCharStream.currentBuffer.substring(htmlStart, currentPosition);
 316     pushOnAstNodes(new HTMLCode(html, htmlStart,currentPosition));
 317   }
 318
 319   /** Create a new task. */
 320   public static final void createNewTask(final int todoStart) {
 321     final String  todo = SimpleCharStream.currentBuffer.substring(todoStart,
 322                                                                   SimpleCharStream.currentBuffer.indexOf("\n",
 323                                                                                                          todoStart)-1);
 324     if (!PARSER_DEBUG) {
 325       try {
 326         setMarker(fileToParse,
 327                   todo,
 328                   SimpleCharStream.getBeginLine(),
 329                   TASK,
 330                   "Line "+SimpleCharStream.getBeginLine());
 331       } catch (CoreException e) {
 332         PHPeclipsePlugin.log(e);
 333       }
 334     }
 335   }
 336
 337   private static final void parse() throws ParseException {
 338           phpFile();
 339   }
 340
 341   static final public void todo() throws ParseException {
 342  Token todoToken;
 343     todoToken = jj_consume_token(23);
 344                       createNewTask(todoToken.sourceStart);
 345   }
 346
 347   static final public void phpTest() throws ParseException {
 348     Php();
 349     jj_consume_token(0);
 350   }
 351
 352   static final public void phpFile() throws ParseException {
 353     try {
 354       label_1:
 355       while (true) {
 356         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
 357         case PHPSTARTSHORT:
 358         case PHPSTARTLONG:
 359         case PHPECHOSTART:
 360         case PHPEND:
 361         case CLASS:
 362         case FUNCTION:
 363         case IF:
 364         case ARRAY:
 365         case BREAK:
 366         case LIST:
 367         case PRINT:
 368         case ECHO:
 369         case INCLUDE:
 370         case REQUIRE:
 371         case INCLUDE_ONCE:
 372         case REQUIRE_ONCE:
 373         case GLOBAL:
 374         case DEFINE:
 375         case STATIC:
 376         case CONTINUE:
 377         case DO:
 378         case FOR:
 379         case NEW:
 380         case NULL:
 381         case RETURN:
 382         case SWITCH:
 383         case TRUE:
 384         case FALSE:
 385         case WHILE:
 386         case FOREACH:
 387         case AT:
 388         case BANG:
 389         case TILDE:
 390         case PLUS_PLUS:
 391         case MINUS_MINUS:
 392         case PLUS:
 393         case MINUS:
 394         case BIT_AND:
 395         case INTEGER_LITERAL:
 396         case FLOATING_POINT_LITERAL:
 397         case STRING_LITERAL:
 398         case DOUBLEQUOTE:
 399         case DOLLAR:
 400         case IDENTIFIER:
 401         case LPAREN:
 402         case LBRACE:
 403         case SEMICOLON:
 404           ;
 405           break;
 406         default:
 407           jj_la1[0] = jj_gen;
 408           break label_1;
 409         }
 410         PhpBlock();
 411       }
 412      PHPParser.createNewHTMLCode();
 413     } catch (TokenMgrError e) {
 414     PHPeclipsePlugin.log(e);
 415     errorStart   = SimpleCharStream.beginOffset;
 416     errorEnd     = SimpleCharStream.endOffset;
 417     errorMessage = e.getMessage();
 418     errorLevel   = ERROR;
 419     {if (true) throw generateParseException();}
 420     }
 421   }
 422
 423 /**
 424  * A php block is a <?= expression [;]?>
 425  * or <?php somephpcode ?>
 426  * or <? somephpcode ?>
 427  */
 428   static final public void PhpBlock() throws ParseException {
 429   final PHPEchoBlock phpEchoBlock;
 430   final Token token,phpEnd;
 431     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
 432     case PHPECHOSTART:
 433       phpEchoBlock = phpEchoBlock();
 434    pushOnAstNodes(phpEchoBlock);
 435       break;
 436     case PHPSTARTSHORT:
 437     case PHPSTARTLONG:
 438     case PHPEND:
 439     case CLASS:
 440     case FUNCTION:
 441     case IF:
 442     case ARRAY:
 443     case BREAK:
 444     case LIST:
 445     case PRINT:
 446     case ECHO:
 447     case INCLUDE:
 448     case REQUIRE:
 449     case INCLUDE_ONCE:
 450     case REQUIRE_ONCE:
 451     case GLOBAL:
 452     case DEFINE:
 453     case STATIC:
 454     case CONTINUE:
 455     case DO:
 456     case FOR:
 457     case NEW:
 458     case NULL:
 459     case RETURN:
 460     case SWITCH:
 461     case TRUE:
 462     case FALSE:
 463     case WHILE:
 464     case FOREACH:
 465     case AT:
 466     case BANG:
 467     case TILDE:
 468     case PLUS_PLUS:
 469     case MINUS_MINUS:
 470     case PLUS:
 471     case MINUS:
 472     case BIT_AND:
 473     case INTEGER_LITERAL:
 474     case FLOATING_POINT_LITERAL:
 475     case STRING_LITERAL:
 476     case DOUBLEQUOTE:
 477     case DOLLAR:
 478     case IDENTIFIER:
 479     case LPAREN:
 480     case LBRACE:
 481     case SEMICOLON:
 482       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
 483       case PHPSTARTSHORT:
 484       case PHPSTARTLONG:
 485         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
 486         case PHPSTARTLONG:
 487           jj_consume_token(PHPSTARTLONG);
 488           break;
 489         case PHPSTARTSHORT:
 490           token = jj_consume_token(PHPSTARTSHORT);
 491      try {
 492       setMarker(fileToParse,
 493                 "You should use '<?php' instead of '<?' it will avoid some problems with XML",
 494                 token.sourceStart,
 495                 token.sourceEnd,
 496                 INFO,
 497                 "Line " + token.beginLine);
 498     } catch (CoreException e) {
 499       PHPeclipsePlugin.log(e);
 500     }
 501           break;
 502         default:
 503           jj_la1[1] = jj_gen;
 504           jj_consume_token(-1);
 505           throw new ParseException();
 506         }
 507         break;
 508       default:
 509         jj_la1[2] = jj_gen;
 510         ;
 511       }
 512    PHPParser.createNewHTMLCode();
 513       Php();
 514       try {
 515         phpEnd = jj_consume_token(PHPEND);
 516     htmlStart = phpEnd.sourceEnd;
 517       } catch (ParseException e) {
 518     errorMessage = "'?>' expected";
 519     errorLevel   = ERROR;
 520     errorStart = e.currentToken.sourceStart;
 521     errorEnd   = e.currentToken.sourceEnd;
 522     processParseExceptionDebug(e);
 523       }
 524       break;
 525     default:
 526       jj_la1[3] = jj_gen;
 527       jj_consume_token(-1);
 528       throw new ParseException();
 529     }
 530   }
 531
 532   static final public PHPEchoBlock phpEchoBlock() throws ParseException {
 533   final Expression expr;
 534   final PHPEchoBlock echoBlock;
 535   final Token token, token2;
 536     token = jj_consume_token(PHPECHOSTART);
 537                           PHPParser.createNewHTMLCode();
 538     expr = Expression();
 539     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
 540     case SEMICOLON:
 541       jj_consume_token(SEMICOLON);
 542       break;
 543     default:
 544       jj_la1[4] = jj_gen;
 545       ;
 546     }
 547     token2 = jj_consume_token(PHPEND);
 548   htmlStart = token2.sourceEnd;
 549
 550   echoBlock = new PHPEchoBlock(expr,token.sourceStart,token2.sourceEnd);
 551   pushOnAstNodes(echoBlock);
 552   {if (true) return echoBlock;}
 553     throw new Error("Missing return statement in function");
 554   }
 555
 556   static final public void Php() throws ParseException {
 557     label_2:
 558     while (true) {
 559       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
 560       case CLASS:
 561       case FUNCTION:
 562       case IF:
 563       case ARRAY:
 564       case BREAK:
 565       case LIST:
 566       case PRINT:
 567       case ECHO:
 568       case INCLUDE:
 569       case REQUIRE:
 570       case INCLUDE_ONCE:
 571       case REQUIRE_ONCE:
 572       case GLOBAL:
 573       case DEFINE:
 574       case STATIC:
 575       case CONTINUE:
 576       case DO:
 577       case FOR:
 578       case NEW:
 579       case NULL:
 580       case RETURN:
 581       case SWITCH:
 582       case TRUE:
 583       case FALSE:
 584       case WHILE:
 585       case FOREACH:
 586       case AT:
 587       case BANG:
 588       case TILDE:
 589       case PLUS_PLUS:
 590       case MINUS_MINUS:
 591       case PLUS:
 592       case MINUS:
 593       case BIT_AND:
 594       case INTEGER_LITERAL:
 595       case FLOATING_POINT_LITERAL:
 596       case STRING_LITERAL:
 597       case DOUBLEQUOTE:
 598       case DOLLAR:
 599       case IDENTIFIER:
 600       case LPAREN:
 601       case LBRACE:
 602       case SEMICOLON:
 603         ;
 604         break;
 605       default:
 606         jj_la1[5] = jj_gen;
 607         break label_2;
 608       }
 609       BlockStatement();
 610     }
 611   }
 612
 613   static final public ClassDeclaration ClassDeclaration() throws ParseException {
 614   final ClassDeclaration classDeclaration;
 615   Token className = null;
 616   final Token superclassName, token, extendsToken;
 617   String classNameImage = SYNTAX_ERROR_CHAR;
 618   String superclassNameImage = null;
 619   final int classEnd;
 620     token = jj_consume_token(CLASS);
 621     try {
 622       className = jj_consume_token(IDENTIFIER);
 623      classNameImage = className.image;
 624     } catch (ParseException e) {
 625     errorMessage = "unexpected token : '"+ e.currentToken.next.image +"', identifier expected";
 626     errorLevel   = ERROR;
 627     errorStart   = token.sourceEnd+1;
 628     errorEnd     = token.sourceEnd+1;
 629     processParseExceptionDebug(e);
 630     }
 631     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
 632     case EXTENDS:
 633       extendsToken = jj_consume_token(EXTENDS);
 634       try {
 635         superclassName = jj_consume_token(IDENTIFIER);
 636        superclassNameImage = superclassName.image;
 637       } catch (ParseException e) {
 638       errorMessage = "unexpected token : '"+ e.currentToken.next.image +"', identifier expected";
 639       errorLevel   = ERROR;
 640       errorStart = extendsToken.sourceEnd+1;
 641       errorEnd   = extendsToken.sourceEnd+1;
 642       processParseExceptionDebug(e);
 643       superclassNameImage = SYNTAX_ERROR_CHAR;
 644       }
 645       break;
 646     default:
 647       jj_la1[6] = jj_gen;
 648       ;
 649     }
 650     int start, end;
 651     if (className == null) {
 652       start = token.sourceStart;
 653       end = token.sourceEnd;
 654     } else {
 655       start = className.sourceStart;
 656       end = className.sourceEnd;
 657     }
 658     if (superclassNameImage == null) {
 659
 660       classDeclaration = new ClassDeclaration(currentSegment,
 661                                               classNameImage,
 662                                               start,
 663                                               end);
 664     } else {
 665       classDeclaration = new ClassDeclaration(currentSegment,
 666                                               classNameImage,
 667                                               superclassNameImage,
 668                                               start,
 669                                               end);
 670     }
 671       currentSegment.add(classDeclaration);
 672       currentSegment = classDeclaration;
 673     classEnd = ClassBody(classDeclaration);
 674    currentSegment = (OutlineableWithChildren) currentSegment.getParent();
 675    classDeclaration.sourceEnd = classEnd;
 676    pushOnAstNodes(classDeclaration);
 677    {if (true) return classDeclaration;}
 678     throw new Error("Missing return statement in function");
 679   }
 680
 681   static final public int ClassBody(final ClassDeclaration classDeclaration) throws ParseException {
 682 Token token;
 683     try {
 684       jj_consume_token(LBRACE);
 685     } catch (ParseException e) {
 686     errorMessage = "unexpected token : '"+ e.currentToken.next.image + "'. '{' expected";
 687     errorLevel   = ERROR;
 688     errorStart = e.currentToken.sourceStart;
 689     errorEnd   = e.currentToken.sourceEnd;
 690     processParseExceptionDebug(e);
 691     }
 692     label_3:
 693     while (true) {
 694       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
 695       case FUNCTION:
 696       case VAR:
 697         ;
 698         break;
 699       default:
 700         jj_la1[7] = jj_gen;
 701         break label_3;
 702       }
 703       ClassBodyDeclaration(classDeclaration);
 704     }
 705     try {
 706       token = jj_consume_token(RBRACE);
 707      {if (true) return token.sourceEnd;}
 708     } catch (ParseException e) {
 709     errorMessage = "unexpected token : '"+ e.currentToken.next.image +"'. 'var', 'function' or '}' expected";
 710     errorLevel   = ERROR;
 711     errorStart = e.currentToken.sourceStart;
 712     errorEnd   = e.currentToken.sourceEnd;
 713     processParseExceptionDebug(e);
 714     {if (true) return PHPParser.token.sourceEnd;}
 715     }
 716     throw new Error("Missing return statement in function");
 717   }
 718
 719 /**
 720  * A class can contain only methods and fields.
 721  */
 722   static final public void ClassBodyDeclaration(final ClassDeclaration classDeclaration) throws ParseException {
 723   final MethodDeclaration method;
 724   final FieldDeclaration field;
 725     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
 726     case FUNCTION:
 727       method = MethodDeclaration();
 728                                 method.analyzeCode();
 729                                 classDeclaration.addMethod(method);
 730       break;
 731     case VAR:
 732       field = FieldDeclaration();
 733                                 classDeclaration.addField(field);
 734       break;
 735     default:
 736       jj_la1[8] = jj_gen;
 737       jj_consume_token(-1);
 738       throw new ParseException();
 739     }
 740   }
 741
 742 /**
 743  * A class field declaration : it's var VariableDeclarator() (, VariableDeclarator())*;.
 744  * it is only used by ClassBodyDeclaration()
 745  */
 746   static final public FieldDeclaration FieldDeclaration() throws ParseException {
 747   VariableDeclaration variableDeclaration;
 748   final VariableDeclaration[] list;
 749   final ArrayList arrayList = new ArrayList();
 750   final Token token;
 751   Token token2 = null;
 752   int pos;
 753     token = jj_consume_token(VAR);
 754     variableDeclaration = VariableDeclaratorNoSuffix();
 755     arrayList.add(variableDeclaration);
 756     pos = variableDeclaration.sourceEnd;
 757     label_4:
 758     while (true) {
 759       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
 760       case COMMA:
 761         ;
 762         break;
 763       default:
 764         jj_la1[9] = jj_gen;
 765         break label_4;
 766       }
 767       jj_consume_token(COMMA);
 768       variableDeclaration = VariableDeclaratorNoSuffix();
 769         arrayList.add(variableDeclaration);
 770         outlineInfo.addVariable(variableDeclaration.name());
 771         pos = variableDeclaration.sourceEnd;
 772     }
 773     try {
 774       token2 = jj_consume_token(SEMICOLON);
 775     } catch (ParseException e) {
 776     errorMessage = "unexpected token : '"+ e.currentToken.next.image +"'. A ';' was expected after variable declaration";
 777     errorLevel   = ERROR;
 778     errorStart   = pos+1;
 779     errorEnd     = pos+1;
 780     processParseExceptionDebug(e);
 781     }
 782    list = new VariableDeclaration[arrayList.size()];
 783    arrayList.toArray(list);
 784    int end;
 785    if (token2 == null) {
 786      end = list[list.length-1].sourceEnd;
 787    } else {
 788      end = token2.sourceEnd;
 789    }
 790    {if (true) return new FieldDeclaration(list,
 791                                token.sourceStart,
 792                                end,
 793                                currentSegment);}
 794     throw new Error("Missing return statement in function");
 795   }
 796
 797 /**
 798  * a strict variable declarator : there cannot be a suffix here.
 799  * It will be used by fields and formal parameters
 800  */
 801   static final public VariableDeclaration VariableDeclaratorNoSuffix() throws ParseException {
 802   final Token token, lbrace,rbrace;
 803   Expression expr, initializer = null;
 804   Token assignToken;
 805   Variable variable;
 806     jj_consume_token(DOLLAR);
 807     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
 808     case IDENTIFIER:
 809       token = jj_consume_token(IDENTIFIER);
 810       variable = new Variable(token.image,token.sourceStart,token.sourceEnd);
 811       break;
 812     case LBRACE:
 813       lbrace = jj_consume_token(LBRACE);
 814       expr = Expression();
 815       rbrace = jj_consume_token(RBRACE);
 816       variable = new Variable(expr,lbrace.sourceStart,rbrace.sourceEnd);
 817       break;
 818     default:
 819       jj_la1[10] = jj_gen;
 820       jj_consume_token(-1);
 821       throw new ParseException();
 822     }
 823     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
 824     case ASSIGN:
 825       assignToken = jj_consume_token(ASSIGN);
 826       try {
 827         initializer = VariableInitializer();
 828       } catch (ParseException e) {
 829       errorMessage = "Literal expression expected in variable initializer";
 830       errorLevel   = ERROR;
 831       errorStart = assignToken.sourceEnd +1;
 832       errorEnd   = assignToken.sourceEnd +1;
 833       processParseExceptionDebug(e);
 834       }
 835       break;
 836     default:
 837       jj_la1[11] = jj_gen;
 838       ;
 839     }
 840   if (initializer == null) {
 841     {if (true) return new VariableDeclaration(currentSegment,
 842                                    variable,
 843                                    variable.sourceStart,
 844                                    variable.sourceEnd);}
 845   }
 846   {if (true) return new VariableDeclaration(currentSegment,
 847                                  variable,
 848                                  initializer,
 849                                  VariableDeclaration.EQUAL,
 850                                  variable.sourceStart);}
 851     throw new Error("Missing return statement in function");
 852   }
 853
 854 /**
 855  * this will be used by static statement
 856  */
 857   static final public VariableDeclaration VariableDeclarator() throws ParseException {
 858   final AbstractVariable variable;
 859   Expression initializer = null;
 860   final Token token;
 861     variable = VariableDeclaratorId();
 862     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
 863     case ASSIGN:
 864       token = jj_consume_token(ASSIGN);
 865       try {
 866         initializer = VariableInitializer();
 867       } catch (ParseException e) {
 868       errorMessage = "Literal expression expected in variable initializer";
 869       errorLevel   = ERROR;
 870       errorStart = token.sourceEnd+1;
 871       errorEnd   = token.sourceEnd+1;
 872       processParseExceptionDebug(e);
 873       }
 874       break;
 875     default:
 876       jj_la1[12] = jj_gen;
 877       ;
 878     }
 879   if (initializer == null) {
 880     {if (true) return new VariableDeclaration(currentSegment,
 881                                    variable,
 882                                    variable.sourceStart,
 883                                    variable.sourceEnd);}
 884   }
 885     {if (true) return new VariableDeclaration(currentSegment,
 886                                    variable,
 887                                    initializer,
 888                                    VariableDeclaration.EQUAL,
 889                                    variable.sourceStart);}
 890     throw new Error("Missing return statement in function");
 891   }
 892
 893 /**
 894  * A Variable name.
 895  * @return the variable name (with suffix)
 896  */
 897   static final public AbstractVariable VariableDeclaratorId() throws ParseException {
 898   final Variable var;
 899   AbstractVariable expression = null;
 900     try {
 901       var = Variable();
 902       label_5:
 903       while (true) {
 904         if (jj_2_1(2)) {
 905           ;
 906         } else {
 907           break label_5;
 908         }
 909         expression = VariableSuffix(var);
 910       }
 911      if (expression == null) {
 912        {if (true) return var;}
 913      }
 914      {if (true) return expression;}
 915     } catch (ParseException e) {
 916     errorMessage = "'$' expected for variable identifier";
 917     errorLevel   = ERROR;
 918     errorStart = e.currentToken.sourceStart;
 919     errorEnd   = e.currentToken.sourceEnd;
 920     {if (true) throw e;}
 921     }
 922     throw new Error("Missing return statement in function");
 923   }
 924
 925   static final public Variable Variable() throws ParseException {
 926   Variable variable = null;
 927   final Token token;
 928     token = jj_consume_token(DOLLAR);
 929     variable = Var();
 930     {if (true) return variable;}
 931     throw new Error("Missing return statement in function");
 932   }
 933
 934   static final public Variable Var() throws ParseException {
 935   Variable variable = null;
 936   final Token token,token2;
 937   ConstantIdentifier constant;
 938   Expression expression;
 939     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
 940     case DOLLAR:
 941       token = jj_consume_token(DOLLAR);
 942       variable = Var();
 943    {if (true) return new Variable(variable,variable.sourceStart,variable.sourceEnd);}
 944       break;
 945     case LBRACE:
 946       token = jj_consume_token(LBRACE);
 947       expression = Expression();
 948       token2 = jj_consume_token(RBRACE);
 949    {if (true) return new Variable(expression,
 950                        token.sourceStart,
 951                        token2.sourceEnd);}
 952       break;
 953     case IDENTIFIER:
 954       token = jj_consume_token(IDENTIFIER);
 955    outlineInfo.addVariable('$' + token.image);
 956    {if (true) return new Variable(token.image,token.sourceStart,token.sourceEnd);}
 957       break;
 958     default:
 959       jj_la1[13] = jj_gen;
 960       jj_consume_token(-1);
 961       throw new ParseException();
 962     }
 963     throw new Error("Missing return statement in function");
 964   }
 965
 966   static final public Expression VariableInitializer() throws ParseException {
 967   final Expression expr;
 968   final Token token, token2;
 969     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
 970     case NULL:
 971     case TRUE:
 972     case FALSE:
 973     case INTEGER_LITERAL:
 974     case FLOATING_POINT_LITERAL:
 975     case STRING_LITERAL:
 976     case DOUBLEQUOTE:
 977       expr = Literal();
 978    {if (true) return expr;}
 979       break;
 980     case MINUS:
 981       token2 = jj_consume_token(MINUS);
 982       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
 983       case INTEGER_LITERAL:
 984         token = jj_consume_token(INTEGER_LITERAL);
 985         break;
 986       case FLOATING_POINT_LITERAL:
 987         token = jj_consume_token(FLOATING_POINT_LITERAL);
 988         break;
 989       default:
 990         jj_la1[14] = jj_gen;
 991         jj_consume_token(-1);
 992         throw new ParseException();
 993       }
 994    {if (true) return new PrefixedUnaryExpression(new NumberLiteral(token),
 995                                       OperatorIds.MINUS,
 996                                       token2.sourceStart);}
 997       break;
 998     case PLUS:
 999       token2 = jj_consume_token(PLUS);
1000       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1001       case INTEGER_LITERAL:
1002         token = jj_consume_token(INTEGER_LITERAL);
1003         break;
1004       case FLOATING_POINT_LITERAL:
1005         token = jj_consume_token(FLOATING_POINT_LITERAL);
1006         break;
1007       default:
1008         jj_la1[15] = jj_gen;
1009         jj_consume_token(-1);
1010         throw new ParseException();
1011       }
1012    {if (true) return new PrefixedUnaryExpression(new NumberLiteral(token),
1013                                       OperatorIds.PLUS,
1014                                       token2.sourceStart);}
1015       break;
1016     case ARRAY:
1017       expr = ArrayDeclarator();
1018    {if (true) return expr;}
1019       break;
1020     case IDENTIFIER:
1021       token = jj_consume_token(IDENTIFIER);
1022    {if (true) return new ConstantIdentifier(token);}
1023       break;
1024     default:
1025       jj_la1[16] = jj_gen;
1026       jj_consume_token(-1);
1027       throw new ParseException();
1028     }
1029     throw new Error("Missing return statement in function");
1030   }
1031
1032   static final public ArrayVariableDeclaration ArrayVariable() throws ParseException {
1033 final Expression expr,expr2;
1034     expr = Expression();
1035     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1036     case ARRAYASSIGN:
1037       jj_consume_token(ARRAYASSIGN);
1038       expr2 = Expression();
1039      {if (true) return new ArrayVariableDeclaration(expr,expr2);}
1040       break;
1041     default:
1042       jj_la1[17] = jj_gen;
1043       ;
1044     }
1045    {if (true) return new ArrayVariableDeclaration(expr,SimpleCharStream.getPosition());}
1046     throw new Error("Missing return statement in function");
1047   }
1048
1049   static final public ArrayVariableDeclaration[] ArrayInitializer() throws ParseException {
1050   ArrayVariableDeclaration expr;
1051   final ArrayList list = new ArrayList();
1052     jj_consume_token(LPAREN);
1053     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1054     case ARRAY:
1055     case LIST:
1056     case PRINT:
1057     case NEW:
1058     case NULL:
1059     case TRUE:
1060     case FALSE:
1061     case AT:
1062     case BANG:
1063     case TILDE:
1064     case PLUS_PLUS:
1065     case MINUS_MINUS:
1066     case PLUS:
1067     case MINUS:
1068     case BIT_AND:
1069     case INTEGER_LITERAL:
1070     case FLOATING_POINT_LITERAL:
1071     case STRING_LITERAL:
1072     case DOUBLEQUOTE:
1073     case DOLLAR:
1074     case IDENTIFIER:
1075     case LPAREN:
1076       expr = ArrayVariable();
1077        list.add(expr);
1078       label_6:
1079       while (true) {
1080         if (jj_2_2(2)) {
1081           ;
1082         } else {
1083           break label_6;
1084         }
1085         jj_consume_token(COMMA);
1086         expr = ArrayVariable();
1087        list.add(expr);
1088       }
1089       break;
1090     default:
1091       jj_la1[18] = jj_gen;
1092       ;
1093     }
1094     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1095     case COMMA:
1096       jj_consume_token(COMMA);
1097                list.add(null);
1098       break;
1099     default:
1100       jj_la1[19] = jj_gen;
1101       ;
1102     }
1103     jj_consume_token(RPAREN);
1104   final ArrayVariableDeclaration[] vars = new ArrayVariableDeclaration[list.size()];
1105   list.toArray(vars);
1106   {if (true) return vars;}
1107     throw new Error("Missing return statement in function");
1108   }
1109
1110 /**
1111  * A Method Declaration.
1112  * <b>function</b> MetodDeclarator() Block()
1113  */
1114   static final public MethodDeclaration MethodDeclaration() throws ParseException {
1115   final MethodDeclaration functionDeclaration;
1116   final Block block;
1117   final OutlineableWithChildren seg = currentSegment;
1118   final Token token;
1119     token = jj_consume_token(FUNCTION);
1120     try {
1121       functionDeclaration = MethodDeclarator(token.sourceStart);
1122      outlineInfo.addVariable(functionDeclaration.name);
1123     } catch (ParseException e) {
1124     if (errorMessage != null)  {if (true) throw e;}
1125     errorMessage = "unexpected token : '"+ e.currentToken.next.image +"', function identifier expected";
1126     errorLevel   = ERROR;
1127     errorStart = e.currentToken.sourceStart;
1128     errorEnd   = e.currentToken.sourceEnd;
1129     {if (true) throw e;}
1130     }
1131    currentSegment = functionDeclaration;
1132     block = Block();
1133    functionDeclaration.statements = block.statements;
1134    currentSegment = seg;
1135    {if (true) return functionDeclaration;}
1136     throw new Error("Missing return statement in function");
1137   }
1138
1139 /**
1140  * A MethodDeclarator.
1141  * [&] IDENTIFIER(parameters ...).
1142  * @return a function description for the outline
1143  */
1144   static final public MethodDeclaration MethodDeclarator(final int start) throws ParseException {
1145   Token identifier = null;
1146   Token reference = null;
1147   final ArrayList formalParameters = new ArrayList();
1148   String identifierChar = SYNTAX_ERROR_CHAR;
1149   int end = start;
1150     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1151     case BIT_AND:
1152       reference = jj_consume_token(BIT_AND);
1153                           end = reference.sourceEnd;
1154       break;
1155     default:
1156       jj_la1[20] = jj_gen;
1157       ;
1158     }
1159     try {
1160       identifier = jj_consume_token(IDENTIFIER);
1161       identifierChar = identifier.image;
1162       end = identifier.sourceEnd;
1163     } catch (ParseException e) {
1164     errorMessage = "unexpected token : '"+ e.currentToken.next.image +"', function identifier expected";
1165     errorLevel   = ERROR;
1166     errorStart = e.currentToken.sourceEnd;
1167     errorEnd   = e.currentToken.next.sourceStart;
1168     processParseExceptionDebug(e);
1169     }
1170     end = FormalParameters(formalParameters);
1171   int nameStart, nameEnd;
1172   if (identifier == null) {
1173     if (reference == null) {
1174       nameStart = start + 9;
1175       nameEnd = start + 10;
1176     } else {
1177       nameStart = reference.sourceEnd + 1;
1178       nameEnd = reference.sourceEnd + 2;
1179     }
1180   } else {
1181       nameStart = identifier.sourceStart;
1182       nameEnd = identifier.sourceEnd;
1183   }
1184   {if (true) return new MethodDeclaration(currentSegment,
1185                                identifierChar,
1186                                formalParameters,
1187                                reference != null,
1188                                nameStart,
1189                                nameEnd,
1190                                start,
1191                                end);}
1192     throw new Error("Missing return statement in function");
1193   }
1194
1195 /**
1196  * FormalParameters follows method identifier.
1197  * (FormalParameter())
1198  */
1199   static final public int FormalParameters(final ArrayList parameters) throws ParseException {
1200   VariableDeclaration var;
1201   final Token token;
1202   Token tok = PHPParser.token;
1203   int end = tok.sourceEnd;
1204     try {
1205       tok = jj_consume_token(LPAREN);
1206    end = tok.sourceEnd;
1207     } catch (ParseException e) {
1208     errorMessage = "unexpected token : '"+ e.currentToken.next.image +"', '(' expected after function identifier";
1209     errorLevel   = ERROR;
1210     errorStart = e.currentToken.next.sourceStart;
1211     errorEnd   = e.currentToken.next.sourceEnd;
1212     processParseExceptionDebug(e);
1213     }
1214     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1215     case BIT_AND:
1216     case DOLLAR:
1217       var = FormalParameter();
1218      parameters.add(var);end = var.sourceEnd;
1219       label_7:
1220       while (true) {
1221         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1222         case COMMA:
1223           ;
1224           break;
1225         default:
1226           jj_la1[21] = jj_gen;
1227           break label_7;
1228         }
1229         jj_consume_token(COMMA);
1230         var = FormalParameter();
1231        parameters.add(var);end = var.sourceEnd;
1232       }
1233       break;
1234     default:
1235       jj_la1[22] = jj_gen;
1236       ;
1237     }
1238     try {
1239       token = jj_consume_token(RPAREN);
1240      end = token.sourceEnd;
1241     } catch (ParseException e) {
1242     errorMessage = "')' expected";
1243     errorLevel   = ERROR;
1244     errorStart = e.currentToken.next.sourceStart;
1245     errorEnd   = e.currentToken.next.sourceEnd;
1246     processParseExceptionDebug(e);
1247     }
1248   {if (true) return end;}
1249     throw new Error("Missing return statement in function");
1250   }
1251
1252 /**
1253  * A formal parameter.
1254  * $varname[=value] (,$varname[=value])
1255  */
1256   static final public VariableDeclaration FormalParameter() throws ParseException {
1257   final VariableDeclaration variableDeclaration;
1258   Token token = null;
1259     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1260     case BIT_AND:
1261       token = jj_consume_token(BIT_AND);
1262       break;
1263     default:
1264       jj_la1[23] = jj_gen;
1265       ;
1266     }
1267     variableDeclaration = VariableDeclaratorNoSuffix();
1268     outlineInfo.addVariable('$'+variableDeclaration.name());
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   int sourceEnd = (args == null && args.length != 0) ? lparen.sourceEnd+1 : args[args.length-1].sourceEnd;
2770   {if (true) return new FunctionCall(func,args,sourceEnd);}
2771     throw new Error("Missing return statement in function");
2772   }
2773
2774 /**
2775  * An argument list is a list of arguments separated by comma :
2776  * argumentDeclaration() (, argumentDeclaration)*
2777  * @return an array of arguments
2778  */
2779   static final public Expression[] ArgumentList() throws ParseException {
2780 Expression arg;
2781 final ArrayList list = new ArrayList();
2782 int pos;
2783 Token token;
2784     arg = Expression();
2785    list.add(arg);pos = arg.sourceEnd;
2786     label_21:
2787     while (true) {
2788       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2789       case COMMA:
2790         ;
2791         break;
2792       default:
2793         jj_la1[75] = jj_gen;
2794         break label_21;
2795       }
2796       token = jj_consume_token(COMMA);
2797                      pos = token.sourceEnd;
2798       try {
2799         arg = Expression();
2800          list.add(arg);
2801          pos = arg.sourceEnd;
2802       } catch (ParseException e) {
2803         errorMessage = "unexpected token : '"+ e.currentToken.next.image +"'. An expression expected after a comma in argument list";
2804         errorLevel   = ERROR;
2805         errorStart   = pos+1;
2806         errorEnd     = pos+1;
2807         processParseException(e);
2808       }
2809     }
2810    final Expression[] arguments = new Expression[list.size()];
2811    list.toArray(arguments);
2812    {if (true) return arguments;}
2813     throw new Error("Missing return statement in function");
2814   }
2815
2816 /**
2817  * A Statement without break.
2818  * @return a statement
2819  */
2820   static final public Statement StatementNoBreak() throws ParseException {
2821   final Statement statement;
2822   Token token = null;
2823     if (jj_2_4(2)) {
2824       statement = expressionStatement();
2825                                          {if (true) return statement;}
2826     } else {
2827       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2828       case IDENTIFIER:
2829         statement = LabeledStatement();
2830                                          {if (true) return statement;}
2831         break;
2832       case LBRACE:
2833         statement = Block();
2834                                          {if (true) return statement;}
2835         break;
2836       case SEMICOLON:
2837         statement = EmptyStatement();
2838                                          {if (true) return statement;}
2839         break;
2840       case SWITCH:
2841         statement = SwitchStatement();
2842                                          {if (true) return statement;}
2843         break;
2844       case IF:
2845         statement = IfStatement();
2846                                          {if (true) return statement;}
2847         break;
2848       case WHILE:
2849         statement = WhileStatement();
2850                                          {if (true) return statement;}
2851         break;
2852       case DO:
2853         statement = DoStatement();
2854                                          {if (true) return statement;}
2855         break;
2856       case FOR:
2857         statement = ForStatement();
2858                                          {if (true) return statement;}
2859         break;
2860       case FOREACH:
2861         statement = ForeachStatement();
2862                                          {if (true) return statement;}
2863         break;
2864       case CONTINUE:
2865         statement = ContinueStatement();
2866                                          {if (true) return statement;}
2867         break;
2868       case RETURN:
2869         statement = ReturnStatement();
2870                                          {if (true) return statement;}
2871         break;
2872       case ECHO:
2873         statement = EchoStatement();
2874                                          {if (true) return statement;}
2875         break;
2876       case INCLUDE:
2877       case REQUIRE:
2878       case INCLUDE_ONCE:
2879       case REQUIRE_ONCE:
2880       case AT:
2881         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2882         case AT:
2883           token = jj_consume_token(AT);
2884           break;
2885         default:
2886           jj_la1[76] = jj_gen;
2887           ;
2888         }
2889         statement = IncludeStatement();
2890    if (token != null) {
2891     ((InclusionStatement)statement).silent = true;
2892     statement.sourceStart = token.sourceStart;
2893   }
2894   {if (true) return statement;}
2895         break;
2896       case STATIC:
2897         statement = StaticStatement();
2898                                          {if (true) return statement;}
2899         break;
2900       case GLOBAL:
2901         statement = GlobalStatement();
2902                                          {if (true) return statement;}
2903         break;
2904       case DEFINE:
2905         statement = defineStatement();
2906                                          currentSegment.add((Outlineable)statement);{if (true) return statement;}
2907         break;
2908       default:
2909         jj_la1[77] = jj_gen;
2910         jj_consume_token(-1);
2911         throw new ParseException();
2912       }
2913     }
2914     throw new Error("Missing return statement in function");
2915   }
2916
2917 /**
2918  * A statement expression.
2919  * expression ;
2920  * @return an expression
2921  */
2922   static final public Statement expressionStatement() throws ParseException {
2923   final Statement statement;
2924   final Token token;
2925     statement = Expression();
2926     try {
2927       token = jj_consume_token(SEMICOLON);
2928      statement.sourceEnd = token.sourceEnd;
2929     } catch (ParseException e) {
2930     if (e.currentToken.next.kind != PHPParserConstants.PHPEND) {
2931       errorMessage = "unexpected token : '"+ e.currentToken.next.image +"'. A ';' was expected";
2932       errorLevel   = ERROR;
2933       errorStart = statement.sourceEnd+1;
2934       errorEnd   = statement.sourceEnd+1;
2935       processParseExceptionDebug(e);
2936     }
2937     }
2938    {if (true) return statement;}
2939     throw new Error("Missing return statement in function");
2940   }
2941
2942   static final public Define defineStatement() throws ParseException {
2943   Expression defineName,defineValue;
2944   final Token defineToken;
2945   Token token;
2946   int pos;
2947     defineToken = jj_consume_token(DEFINE);
2948                           pos = defineToken.sourceEnd+1;
2949     try {
2950       token = jj_consume_token(LPAREN);
2951      pos = token.sourceEnd+1;
2952     } catch (ParseException e) {
2953     errorMessage = "unexpected token : '"+ e.currentToken.next.image +"', '(' expected";
2954     errorLevel   = ERROR;
2955     errorStart   = pos;
2956     errorEnd     = pos;
2957     processParseExceptionDebug(e);
2958     }
2959     try {
2960       defineName = Expression();
2961      pos = defineName.sourceEnd+1;
2962     } catch (ParseException e) {
2963     errorMessage = "unexpected token : '"+ e.currentToken.next.image +"', expression expected";
2964     errorLevel   = ERROR;
2965     errorStart   = pos;
2966     errorEnd     = pos;
2967     processParseExceptionDebug(e);
2968     defineName = new StringLiteral(SYNTAX_ERROR_CHAR,pos,pos);
2969     }
2970     try {
2971       token = jj_consume_token(COMMA);
2972      pos = defineName.sourceEnd+1;
2973     } catch (ParseException e) {
2974     errorMessage = "unexpected token : '"+ e.currentToken.next.image +"', ',' expected";
2975     errorLevel   = ERROR;
2976     errorStart   = pos;
2977     errorEnd     = pos;
2978     processParseExceptionDebug(e);
2979     }
2980     try {
2981       defineValue = Expression();
2982      pos = defineValue.sourceEnd+1;
2983     } catch (ParseException e) {
2984     errorMessage = "unexpected token : '"+ e.currentToken.next.image +"', expression expected";
2985     errorLevel   = ERROR;
2986     errorStart   = pos;
2987     errorEnd     = pos;
2988     processParseExceptionDebug(e);
2989     defineValue = new StringLiteral(SYNTAX_ERROR_CHAR,pos,pos);
2990     }
2991     try {
2992       token = jj_consume_token(RPAREN);
2993      pos = token.sourceEnd+1;
2994     } catch (ParseException e) {
2995     errorMessage = "unexpected token : '"+ e.currentToken.next.image +"', ')' expected";
2996     errorLevel   = ERROR;
2997     errorStart   = pos;
2998     errorEnd     = pos;
2999     processParseExceptionDebug(e);
3000     }
3001    {if (true) return new Define(currentSegment,
3002                      defineName,
3003                      defineValue,
3004                      defineToken.sourceStart,
3005                      pos);}
3006     throw new Error("Missing return statement in function");
3007   }
3008
3009 /**
3010  * A Normal statement.
3011  */
3012   static final public Statement Statement() throws ParseException {
3013   final Statement statement;
3014     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3015     case IF:
3016     case ARRAY:
3017     case LIST:
3018     case PRINT:
3019     case ECHO:
3020     case INCLUDE:
3021     case REQUIRE:
3022     case INCLUDE_ONCE:
3023     case REQUIRE_ONCE:
3024     case GLOBAL:
3025     case DEFINE:
3026     case STATIC:
3027     case CONTINUE:
3028     case DO:
3029     case FOR:
3030     case NEW:
3031     case NULL:
3032     case RETURN:
3033     case SWITCH:
3034     case TRUE:
3035     case FALSE:
3036     case WHILE:
3037     case FOREACH:
3038     case AT:
3039     case BANG:
3040     case TILDE:
3041     case PLUS_PLUS:
3042     case MINUS_MINUS:
3043     case PLUS:
3044     case MINUS:
3045     case BIT_AND:
3046     case INTEGER_LITERAL:
3047     case FLOATING_POINT_LITERAL:
3048     case STRING_LITERAL:
3049     case DOUBLEQUOTE:
3050     case DOLLAR:
3051     case IDENTIFIER:
3052     case LPAREN:
3053     case LBRACE:
3054     case SEMICOLON:
3055       statement = StatementNoBreak();
3056                                   {if (true) return statement;}
3057       break;
3058     case BREAK:
3059       statement = BreakStatement();
3060                                   {if (true) return statement;}
3061       break;
3062     default:
3063       jj_la1[78] = jj_gen;
3064       jj_consume_token(-1);
3065       throw new ParseException();
3066     }
3067     throw new Error("Missing return statement in function");
3068   }
3069
3070 /**
3071  * An html block inside a php syntax.
3072  */
3073   static final public HTMLBlock htmlBlock() throws ParseException {
3074   final int startIndex = nodePtr;
3075   final AstNode[] blockNodes;
3076   final int nbNodes;
3077   final Token phpEnd;
3078     phpEnd = jj_consume_token(PHPEND);
3079    htmlStart = phpEnd.sourceEnd;
3080     label_22:
3081     while (true) {
3082       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3083       case PHPECHOSTART:
3084         ;
3085         break;
3086       default:
3087         jj_la1[79] = jj_gen;
3088         break label_22;
3089       }
3090       phpEchoBlock();
3091     }
3092     try {
3093       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3094       case PHPSTARTLONG:
3095         jj_consume_token(PHPSTARTLONG);
3096         break;
3097       case PHPSTARTSHORT:
3098         jj_consume_token(PHPSTARTSHORT);
3099         break;
3100       default:
3101         jj_la1[80] = jj_gen;
3102         jj_consume_token(-1);
3103         throw new ParseException();
3104       }
3105      PHPParser.createNewHTMLCode();
3106     } catch (ParseException e) {
3107     errorMessage = "unexpected end of file , '<?php' expected";
3108     errorLevel   = ERROR;
3109     errorStart = e.currentToken.sourceStart;
3110     errorEnd   = e.currentToken.sourceEnd;
3111     {if (true) throw e;}
3112     }
3113   nbNodes    = nodePtr - startIndex;
3114   if (nbNodes == 0) {
3115     {if (true) return null;}
3116   }
3117   blockNodes = new AstNode[nbNodes];
3118   System.arraycopy(nodes,startIndex+1,blockNodes,0,nbNodes);
3119   nodePtr = startIndex;
3120   {if (true) return new HTMLBlock(blockNodes);}
3121     throw new Error("Missing return statement in function");
3122   }
3123
3124 /**
3125  * An include statement. It's "include" an expression;
3126  */
3127   static final public InclusionStatement IncludeStatement() throws ParseException {
3128   Expression expr;
3129   final int keyword;
3130   final InclusionStatement inclusionStatement;
3131   final Token token, token2;
3132   int pos;
3133     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3134     case REQUIRE:
3135       token = jj_consume_token(REQUIRE);
3136                                  keyword = InclusionStatement.REQUIRE;pos=token.sourceEnd;
3137       break;
3138     case REQUIRE_ONCE:
3139       token = jj_consume_token(REQUIRE_ONCE);
3140                                  keyword = InclusionStatement.REQUIRE_ONCE;pos=token.sourceEnd;
3141       break;
3142     case INCLUDE:
3143       token = jj_consume_token(INCLUDE);
3144                                  keyword = InclusionStatement.INCLUDE;pos=token.sourceEnd;
3145       break;
3146     case INCLUDE_ONCE:
3147       token = jj_consume_token(INCLUDE_ONCE);
3148                                  keyword = InclusionStatement.INCLUDE_ONCE;pos=token.sourceEnd;
3149       break;
3150     default:
3151       jj_la1[81] = jj_gen;
3152       jj_consume_token(-1);
3153       throw new ParseException();
3154     }
3155     try {
3156       expr = Expression();
3157      pos = expr.sourceEnd;
3158     } catch (ParseException e) {
3159     if (errorMessage != null) {
3160       {if (true) throw e;}
3161     }
3162     errorMessage = "unexpected token '"+ e.currentToken.next.image+"', expression expected";
3163     errorLevel   = ERROR;
3164     errorStart   = e.currentToken.next.sourceStart;
3165     errorEnd     = e.currentToken.next.sourceEnd;
3166     expr = new ConstantIdentifier(SYNTAX_ERROR_CHAR,pos,pos);
3167     processParseExceptionDebug(e);
3168     }
3169     try {
3170       token2 = jj_consume_token(SEMICOLON);
3171      pos=token2.sourceEnd;
3172     } catch (ParseException e) {
3173     errorMessage = "unexpected token : '"+ e.currentToken.next.image +"'. A ';' was expected";
3174     errorLevel   = ERROR;
3175     errorStart   = e.currentToken.next.sourceStart;
3176     errorEnd     = e.currentToken.next.sourceEnd;
3177     processParseExceptionDebug(e);
3178     }
3179    inclusionStatement = new InclusionStatement(currentSegment,
3180                                                keyword,
3181                                                expr,
3182                                                token.sourceStart,
3183                                                pos);
3184    currentSegment.add(inclusionStatement);
3185    {if (true) return inclusionStatement;}
3186     throw new Error("Missing return statement in function");
3187   }
3188
3189   static final public PrintExpression PrintExpression() throws ParseException {
3190   final Expression expr;
3191   final Token printToken;
3192     token = jj_consume_token(PRINT);
3193     expr = Expression();
3194    {if (true) return new PrintExpression(expr,token.sourceStart,expr.sourceEnd);}
3195     throw new Error("Missing return statement in function");
3196   }
3197
3198   static final public ListExpression ListExpression() throws ParseException {
3199   Expression expr = null;
3200   final Expression expression;
3201   final ArrayList list = new ArrayList();
3202   int pos;
3203   final Token listToken, rParen;
3204   Token token;
3205     listToken = jj_consume_token(LIST);
3206                       pos = listToken.sourceEnd;
3207     try {
3208       token = jj_consume_token(LPAREN);
3209                       pos = token.sourceEnd;
3210     } catch (ParseException e) {
3211     errorMessage = "unexpected token : '"+ e.currentToken.next.image +"', '(' expected";
3212     errorLevel   = ERROR;
3213     errorStart   = listToken.sourceEnd+1;
3214     errorEnd     = listToken.sourceEnd+1;
3215     processParseExceptionDebug(e);
3216     }
3217     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3218     case DOLLAR:
3219       expr = VariableDeclaratorId();
3220      list.add(expr);pos = expr.sourceEnd;
3221       break;
3222     default:
3223       jj_la1[82] = jj_gen;
3224       ;
3225     }
3226    if (expr == null) list.add(null);
3227     label_23:
3228     while (true) {
3229       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3230       case COMMA:
3231         ;
3232         break;
3233       default:
3234         jj_la1[83] = jj_gen;
3235         break label_23;
3236       }
3237       try {
3238         token = jj_consume_token(COMMA);
3239        pos = token.sourceEnd;
3240       } catch (ParseException e) {
3241       errorMessage = "unexpected token : '"+ e.currentToken.next.image +"', ',' expected";
3242       errorLevel   = ERROR;
3243       errorStart   = pos+1;
3244       errorEnd     = pos+1;
3245       processParseExceptionDebug(e);
3246       }
3247       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3248       case DOLLAR:
3249         expr = VariableDeclaratorId();
3250                                     list.add(expr);pos = expr.sourceEnd;
3251         break;
3252       default:
3253         jj_la1[84] = jj_gen;
3254         ;
3255       }
3256     }
3257     try {
3258       rParen = jj_consume_token(RPAREN);
3259      pos = rParen.sourceEnd;
3260     } catch (ParseException e) {
3261     errorMessage = "unexpected token : '"+ e.currentToken.next.image +"', ')' expected";
3262     errorLevel   = ERROR;
3263     errorStart = pos+1;
3264     errorEnd   = pos+1;
3265       processParseExceptionDebug(e);
3266     }
3267     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3268     case ASSIGN:
3269       jj_consume_token(ASSIGN);
3270       expression = Expression();
3271     final AbstractVariable[] vars = new AbstractVariable[list.size()];
3272     list.toArray(vars);
3273     {if (true) return new ListExpression(vars,
3274                               expression,
3275                               listToken.sourceStart,
3276                               expression.sourceEnd);}
3277       break;
3278     default:
3279       jj_la1[85] = jj_gen;
3280       ;
3281     }
3282     final AbstractVariable[] vars = new AbstractVariable[list.size()];
3283     list.toArray(vars);
3284     {if (true) return new ListExpression(vars,listToken.sourceStart,pos);}
3285     throw new Error("Missing return statement in function");
3286   }
3287
3288 /**
3289  * An echo statement.
3290  * echo anyexpression (, otherexpression)*
3291  */
3292   static final public EchoStatement EchoStatement() throws ParseException {
3293   final ArrayList expressions = new ArrayList();
3294   Expression expr;
3295   Token token;
3296   Token token2 = null;
3297     token = jj_consume_token(ECHO);
3298     expr = Expression();
3299    expressions.add(expr);
3300     label_24:
3301     while (true) {
3302       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3303       case COMMA:
3304         ;
3305         break;
3306       default:
3307         jj_la1[86] = jj_gen;
3308         break label_24;
3309       }
3310       jj_consume_token(COMMA);
3311       expr = Expression();
3312      expressions.add(expr);
3313     }
3314     try {
3315       token2 = jj_consume_token(SEMICOLON);
3316     } catch (ParseException e) {
3317     if (e.currentToken.next.kind != 4) {
3318       errorMessage = "';' expected after 'echo' statement";
3319       errorLevel   = ERROR;
3320       errorStart   = e.currentToken.sourceEnd;
3321       errorEnd     = e.currentToken.sourceEnd;
3322       processParseExceptionDebug(e);
3323     }
3324     }
3325    final Expression[] exprs = new Expression[expressions.size()];
3326    expressions.toArray(exprs);
3327    if (token2 == null) {
3328      {if (true) return new EchoStatement(exprs,token.sourceStart, exprs[exprs.length-1].sourceEnd);}
3329    }
3330    {if (true) return new EchoStatement(exprs,token.sourceStart, token2.sourceEnd);}
3331     throw new Error("Missing return statement in function");
3332   }
3333
3334   static final public GlobalStatement GlobalStatement() throws ParseException {
3335    Variable expr;
3336    final ArrayList vars = new ArrayList();
3337    final GlobalStatement global;
3338    final Token token, token2;
3339    int pos;
3340     token = jj_consume_token(GLOBAL);
3341     expr = Variable();
3342      vars.add(expr);pos = expr.sourceEnd+1;
3343     label_25:
3344     while (true) {
3345       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3346       case COMMA:
3347         ;
3348         break;
3349       default:
3350         jj_la1[87] = jj_gen;
3351         break label_25;
3352       }
3353       jj_consume_token(COMMA);
3354       expr = Variable();
3355      vars.add(expr);pos = expr.sourceEnd+1;
3356     }
3357     try {
3358       token2 = jj_consume_token(SEMICOLON);
3359      pos = token2.sourceEnd+1;
3360     } catch (ParseException e) {
3361     errorMessage = "unexpected token : '"+ e.currentToken.next.image +"'. a ';' was expected";
3362     errorLevel   = ERROR;
3363     errorStart = pos;
3364     errorEnd   = pos;
3365     processParseExceptionDebug(e);
3366     }
3367     final Variable[] variables = new Variable[vars.size()];
3368     vars.toArray(variables);
3369     global = new GlobalStatement(currentSegment,
3370                                  variables,
3371                                  token.sourceStart,
3372                                  pos);
3373     currentSegment.add(global);
3374     {if (true) return global;}
3375     throw new Error("Missing return statement in function");
3376   }
3377
3378   static final public StaticStatement StaticStatement() throws ParseException {
3379   final ArrayList vars = new ArrayList();
3380   VariableDeclaration expr;
3381   final Token token, token2;
3382   int pos;
3383     token = jj_consume_token(STATIC);
3384     expr = VariableDeclarator();
3385                                                 vars.add(expr);pos = expr.sourceEnd+1;
3386     label_26:
3387     while (true) {
3388       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3389       case COMMA:
3390         ;
3391         break;
3392       default:
3393         jj_la1[88] = jj_gen;
3394         break label_26;
3395       }
3396       jj_consume_token(COMMA);
3397       expr = VariableDeclarator();
3398                                          vars.add(expr);pos = expr.sourceEnd+1;
3399     }
3400     try {
3401       token2 = jj_consume_token(SEMICOLON);
3402      pos = token2.sourceEnd+1;
3403     } catch (ParseException e) {
3404     errorMessage = "unexpected token : '"+ e.currentToken.next.image +"'. a ';' was expected";
3405     errorLevel   = ERROR;
3406     errorStart = pos;
3407     errorEnd   = pos;
3408     processParseException(e);
3409     }
3410     final VariableDeclaration[] variables = new VariableDeclaration[vars.size()];
3411     vars.toArray(variables);
3412     {if (true) return new StaticStatement(variables,
3413                                token.sourceStart,
3414                                pos);}
3415     throw new Error("Missing return statement in function");
3416   }
3417
3418   static final public LabeledStatement LabeledStatement() throws ParseException {
3419   final Token label;
3420   final Statement statement;
3421     label = jj_consume_token(IDENTIFIER);
3422     jj_consume_token(COLON);
3423     statement = Statement();
3424    {if (true) return new LabeledStatement(label.image,statement,label.sourceStart,statement.sourceEnd);}
3425     throw new Error("Missing return statement in function");
3426   }
3427
3428 /**
3429  * A Block is
3430  * {
3431  * statements
3432  * }.
3433  * @return a block
3434  */
3435   static final public Block Block() throws ParseException {
3436   final ArrayList list = new ArrayList();
3437   Statement statement;
3438   final Token token, token2;
3439   int pos,start;
3440     try {
3441       token = jj_consume_token(LBRACE);
3442      pos = token.sourceEnd+1;start=token.sourceStart;
3443     } catch (ParseException e) {
3444     errorMessage = "'{' expected";
3445     errorLevel   = ERROR;
3446     pos = PHPParser.token.sourceEnd+1;
3447     start=pos;
3448     errorStart = pos;
3449     errorEnd   = pos;
3450     processParseExceptionDebug(e);
3451     }
3452     label_27:
3453     while (true) {
3454       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3455       case PHPEND:
3456       case CLASS:
3457       case FUNCTION:
3458       case IF:
3459       case ARRAY:
3460       case BREAK:
3461       case LIST:
3462       case PRINT:
3463       case ECHO:
3464       case INCLUDE:
3465       case REQUIRE:
3466       case INCLUDE_ONCE:
3467       case REQUIRE_ONCE:
3468       case GLOBAL:
3469       case DEFINE:
3470       case STATIC:
3471       case CONTINUE:
3472       case DO:
3473       case FOR:
3474       case NEW:
3475       case NULL:
3476       case RETURN:
3477       case SWITCH:
3478       case TRUE:
3479       case FALSE:
3480       case WHILE:
3481       case FOREACH:
3482       case AT:
3483       case BANG:
3484       case TILDE:
3485       case PLUS_PLUS:
3486       case MINUS_MINUS:
3487       case PLUS:
3488       case MINUS:
3489       case BIT_AND:
3490       case INTEGER_LITERAL:
3491       case FLOATING_POINT_LITERAL:
3492       case STRING_LITERAL:
3493       case DOUBLEQUOTE:
3494       case DOLLAR:
3495       case IDENTIFIER:
3496       case LPAREN:
3497       case LBRACE:
3498       case SEMICOLON:
3499         ;
3500         break;
3501       default:
3502         jj_la1[89] = jj_gen;
3503         break label_27;
3504       }
3505       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3506       case CLASS:
3507       case FUNCTION:
3508       case IF:
3509       case ARRAY:
3510       case BREAK:
3511       case LIST:
3512       case PRINT:
3513       case ECHO:
3514       case INCLUDE:
3515       case REQUIRE:
3516       case INCLUDE_ONCE:
3517       case REQUIRE_ONCE:
3518       case GLOBAL:
3519       case DEFINE:
3520       case STATIC:
3521       case CONTINUE:
3522       case DO:
3523       case FOR:
3524       case NEW:
3525       case NULL:
3526       case RETURN:
3527       case SWITCH:
3528       case TRUE:
3529       case FALSE:
3530       case WHILE:
3531       case FOREACH:
3532       case AT:
3533       case BANG:
3534       case TILDE:
3535       case PLUS_PLUS:
3536       case MINUS_MINUS:
3537       case PLUS:
3538       case MINUS:
3539       case BIT_AND:
3540       case INTEGER_LITERAL:
3541       case FLOATING_POINT_LITERAL:
3542       case STRING_LITERAL:
3543       case DOUBLEQUOTE:
3544       case DOLLAR:
3545       case IDENTIFIER:
3546       case LPAREN:
3547       case LBRACE:
3548       case SEMICOLON:
3549         statement = BlockStatement();
3550                                   list.add(statement);pos = statement.sourceEnd+1;
3551         break;
3552       case PHPEND:
3553         statement = htmlBlock();
3554                                   if (statement != null) {
3555                                     list.add(statement);
3556                                     pos = statement.sourceEnd+1;
3557                                   }
3558                                   pos = PHPParser.token.sourceEnd+1;
3559         break;
3560       default:
3561         jj_la1[90] = jj_gen;
3562         jj_consume_token(-1);
3563         throw new ParseException();
3564       }
3565     }
3566     try {
3567       token2 = jj_consume_token(RBRACE);
3568      pos = token2.sourceEnd+1;
3569     } catch (ParseException e) {
3570     errorMessage = "unexpected token : '"+ e.currentToken.image +"', '}' expected";
3571     errorLevel   = ERROR;
3572     errorStart = pos;
3573     errorEnd   = pos;
3574     processParseExceptionDebug(e);
3575     }
3576   final Statement[] statements = new Statement[list.size()];
3577   list.toArray(statements);
3578   {if (true) return new Block(statements,start,pos);}
3579     throw new Error("Missing return statement in function");
3580   }
3581
3582   static final public Statement BlockStatement() throws ParseException {
3583   final Statement statement;
3584     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3585     case IF:
3586     case ARRAY:
3587     case BREAK:
3588     case LIST:
3589     case PRINT:
3590     case ECHO:
3591     case INCLUDE:
3592     case REQUIRE:
3593     case INCLUDE_ONCE:
3594     case REQUIRE_ONCE:
3595     case GLOBAL:
3596     case DEFINE:
3597     case STATIC:
3598     case CONTINUE:
3599     case DO:
3600     case FOR:
3601     case NEW:
3602     case NULL:
3603     case RETURN:
3604     case SWITCH:
3605     case TRUE:
3606     case FALSE:
3607     case WHILE:
3608     case FOREACH:
3609     case AT:
3610     case BANG:
3611     case TILDE:
3612     case PLUS_PLUS:
3613     case MINUS_MINUS:
3614     case PLUS:
3615     case MINUS:
3616     case BIT_AND:
3617     case INTEGER_LITERAL:
3618     case FLOATING_POINT_LITERAL:
3619     case STRING_LITERAL:
3620     case DOUBLEQUOTE:
3621     case DOLLAR:
3622     case IDENTIFIER:
3623     case LPAREN:
3624     case LBRACE:
3625     case SEMICOLON:
3626       try {
3627         statement = Statement();
3628                                      if (phpDocument == currentSegment) pushOnAstNodes(statement);
3629                                      {if (true) return statement;}
3630       } catch (ParseException e) {
3631     errorMessage = "unexpected token : '"+ e.currentToken.image +"', a statement was expected";
3632     errorLevel   = ERROR;
3633     errorStart = e.currentToken.sourceStart;
3634     errorEnd   = e.currentToken.sourceEnd;
3635     {if (true) throw e;}
3636       }
3637       break;
3638     case CLASS:
3639       statement = ClassDeclaration();
3640                                    {if (true) return statement;}
3641       break;
3642     case FUNCTION:
3643       statement = MethodDeclaration();
3644                                    if (phpDocument == currentSegment) pushOnAstNodes(statement);
3645                                    currentSegment.add((MethodDeclaration) statement);
3646                                    ((MethodDeclaration) statement).analyzeCode();
3647                                    {if (true) return statement;}
3648       break;
3649     default:
3650       jj_la1[91] = jj_gen;
3651       jj_consume_token(-1);
3652       throw new ParseException();
3653     }
3654     throw new Error("Missing return statement in function");
3655   }
3656
3657 /**
3658  * A Block statement that will not contain any 'break'
3659  */
3660   static final public Statement BlockStatementNoBreak() throws ParseException {
3661   final Statement statement;
3662     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3663     case IF:
3664     case ARRAY:
3665     case LIST:
3666     case PRINT:
3667     case ECHO:
3668     case INCLUDE:
3669     case REQUIRE:
3670     case INCLUDE_ONCE:
3671     case REQUIRE_ONCE:
3672     case GLOBAL:
3673     case DEFINE:
3674     case STATIC:
3675     case CONTINUE:
3676     case DO:
3677     case FOR:
3678     case NEW:
3679     case NULL:
3680     case RETURN:
3681     case SWITCH:
3682     case TRUE:
3683     case FALSE:
3684     case WHILE:
3685     case FOREACH:
3686     case AT:
3687     case BANG:
3688     case TILDE:
3689     case PLUS_PLUS:
3690     case MINUS_MINUS:
3691     case PLUS:
3692     case MINUS:
3693     case BIT_AND:
3694     case INTEGER_LITERAL:
3695     case FLOATING_POINT_LITERAL:
3696     case STRING_LITERAL:
3697     case DOUBLEQUOTE:
3698     case DOLLAR:
3699     case IDENTIFIER:
3700     case LPAREN:
3701     case LBRACE:
3702     case SEMICOLON:
3703       statement = StatementNoBreak();
3704                                    {if (true) return statement;}
3705       break;
3706     case CLASS:
3707       statement = ClassDeclaration();
3708                                    {if (true) return statement;}
3709       break;
3710     case FUNCTION:
3711       statement = MethodDeclaration();
3712                                    currentSegment.add((MethodDeclaration) statement);
3713                                    ((MethodDeclaration) statement).analyzeCode();
3714                                    {if (true) return statement;}
3715       break;
3716     default:
3717       jj_la1[92] = jj_gen;
3718       jj_consume_token(-1);
3719       throw new ParseException();
3720     }
3721     throw new Error("Missing return statement in function");
3722   }
3723
3724 /**
3725  * used only by ForInit()
3726  */
3727   static final public Expression[] LocalVariableDeclaration() throws ParseException {
3728   final ArrayList list = new ArrayList();
3729   Expression var;
3730     var = Expression();
3731    list.add(var);
3732     label_28:
3733     while (true) {
3734       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3735       case COMMA:
3736         ;
3737         break;
3738       default:
3739         jj_la1[93] = jj_gen;
3740         break label_28;
3741       }
3742       jj_consume_token(COMMA);
3743       var = Expression();
3744                                 list.add(var);
3745     }
3746     final Expression[] vars = new Expression[list.size()];
3747     list.toArray(vars);
3748     {if (true) return vars;}
3749     throw new Error("Missing return statement in function");
3750   }
3751
3752 /**
3753  * used only by LocalVariableDeclaration().
3754  */
3755   static final public VariableDeclaration LocalVariableDeclarator() throws ParseException {
3756   final Variable varName;
3757   Expression initializer = null;
3758     varName = Variable();
3759     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3760     case ASSIGN:
3761       jj_consume_token(ASSIGN);
3762       initializer = Expression();
3763       break;
3764     default:
3765       jj_la1[94] = jj_gen;
3766       ;
3767     }
3768    if (initializer == null) {
3769     {if (true) return new VariableDeclaration(currentSegment,
3770                                    varName,
3771                                    varName.sourceStart,
3772                                    varName.sourceEnd);}
3773    }
3774     {if (true) return new VariableDeclaration(currentSegment,
3775                                    varName,
3776                                    initializer,
3777                                    VariableDeclaration.EQUAL,
3778                                    varName.sourceStart);}
3779     throw new Error("Missing return statement in function");
3780   }
3781
3782   static final public EmptyStatement EmptyStatement() throws ParseException {
3783   final Token token;
3784     token = jj_consume_token(SEMICOLON);
3785    {if (true) return new EmptyStatement(token.sourceStart,token.sourceEnd);}
3786     throw new Error("Missing return statement in function");
3787   }
3788
3789 /**
3790  * used only by StatementExpressionList() which is used only by ForInit() and ForStatement()
3791  */
3792   static final public Expression StatementExpression() throws ParseException {
3793   final Expression expr;
3794   final Token operator;
3795     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3796     case PLUS_PLUS:
3797     case MINUS_MINUS:
3798       expr = PreIncDecExpression();
3799                                 {if (true) return expr;}
3800       break;
3801     case ARRAY:
3802     case NEW:
3803     case BIT_AND:
3804     case DOLLAR:
3805     case IDENTIFIER:
3806       expr = PrimaryExpression();
3807       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3808       case PLUS_PLUS:
3809       case MINUS_MINUS:
3810         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3811         case PLUS_PLUS:
3812           operator = jj_consume_token(PLUS_PLUS);
3813                             {if (true) return new PostfixedUnaryExpression(expr,
3814                                                                 OperatorIds.PLUS_PLUS,
3815                                                                 operator.sourceEnd);}
3816           break;
3817         case MINUS_MINUS:
3818           operator = jj_consume_token(MINUS_MINUS);
3819                               {if (true) return new PostfixedUnaryExpression(expr,
3820                                                                   OperatorIds.MINUS_MINUS,
3821                                                                   operator.sourceEnd);}
3822           break;
3823         default:
3824           jj_la1[95] = jj_gen;
3825           jj_consume_token(-1);
3826           throw new ParseException();
3827         }
3828         break;
3829       default:
3830         jj_la1[96] = jj_gen;
3831         ;
3832       }
3833    {if (true) return expr;}
3834       break;
3835     default:
3836       jj_la1[97] = jj_gen;
3837       jj_consume_token(-1);
3838       throw new ParseException();
3839     }
3840     throw new Error("Missing return statement in function");
3841   }
3842
3843   static final public SwitchStatement SwitchStatement() throws ParseException {
3844   Expression variable;
3845   final AbstractCase[] cases;
3846   final Token switchToken,lparenToken,rparenToken;
3847   int pos;
3848     switchToken = jj_consume_token(SWITCH);
3849                           pos = switchToken.sourceEnd+1;
3850     try {
3851       lparenToken = jj_consume_token(LPAREN);
3852      pos = lparenToken.sourceEnd+1;
3853     } catch (ParseException e) {
3854     errorMessage = "'(' expected after 'switch'";
3855     errorLevel   = ERROR;
3856     errorStart = pos;
3857     errorEnd   = pos;
3858     processParseExceptionDebug(e);
3859     }
3860     try {
3861       variable = Expression();
3862                              pos = variable.sourceEnd+1;
3863     } catch (ParseException e) {
3864     if (errorMessage != null) {
3865       {if (true) throw e;}
3866     }
3867     errorMessage = "expression expected";
3868     errorLevel   = ERROR;
3869     errorStart = pos;
3870     errorEnd   = pos;
3871     processParseExceptionDebug(e);
3872     variable = new ConstantIdentifier(SYNTAX_ERROR_CHAR,pos,pos);
3873     }
3874     try {
3875       rparenToken = jj_consume_token(RPAREN);
3876                             pos = rparenToken.sourceEnd+1;
3877     } catch (ParseException e) {
3878     errorMessage = "')' expected";
3879     errorLevel   = ERROR;
3880     errorStart = pos;
3881     errorEnd   = pos;
3882     processParseExceptionDebug(e);
3883     }
3884     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3885     case LBRACE:
3886       cases = switchStatementBrace();
3887       break;
3888     case COLON:
3889       cases = switchStatementColon(switchToken.sourceStart, switchToken.sourceEnd);
3890       break;
3891     default:
3892       jj_la1[98] = jj_gen;
3893       jj_consume_token(-1);
3894       throw new ParseException();
3895     }
3896    {if (true) return new SwitchStatement(variable,
3897                               cases,
3898                               switchToken.sourceStart,
3899                               PHPParser.token.sourceEnd);}
3900     throw new Error("Missing return statement in function");
3901   }
3902
3903   static final public AbstractCase[] switchStatementBrace() throws ParseException {
3904   AbstractCase cas;
3905   final ArrayList cases = new ArrayList();
3906   Token token;
3907   int pos;
3908     token = jj_consume_token(LBRACE);
3909                     pos = token.sourceEnd;
3910     label_29:
3911     while (true) {
3912       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3913       case CASE:
3914       case _DEFAULT:
3915         ;
3916         break;
3917       default:
3918         jj_la1[99] = jj_gen;
3919         break label_29;
3920       }
3921       cas = switchLabel0();
3922                          cases.add(cas);pos = cas.sourceEnd;
3923     }
3924     try {
3925       token = jj_consume_token(RBRACE);
3926      pos = token.sourceEnd;
3927     } catch (ParseException e) {
3928     errorMessage = "'}' expected";
3929     errorLevel   = ERROR;
3930     errorStart = pos+1;
3931     errorEnd   = pos+1;
3932     processParseExceptionDebug(e);
3933     }
3934     final AbstractCase[] abcase = new AbstractCase[cases.size()];
3935     cases.toArray(abcase);
3936     {if (true) return abcase;}
3937     throw new Error("Missing return statement in function");
3938   }
3939
3940 /**
3941  * A Switch statement with : ... endswitch;
3942  * @param start the begin offset of the switch
3943  * @param end the end offset of the switch
3944  */
3945   static final public AbstractCase[] switchStatementColon(final int start, final int end) throws ParseException {
3946   AbstractCase cas;
3947   final ArrayList cases = new ArrayList();
3948   Token token;
3949   int pos;
3950     token = jj_consume_token(COLON);
3951                    pos = token.sourceEnd;
3952    try {
3953   setMarker(fileToParse,
3954             "Ugly syntax detected, you should switch () {...} instead of switch (): ... enswitch;",
3955             start,
3956             end,
3957             INFO,
3958             "Line " + token.beginLine);
3959   } catch (CoreException e) {
3960     PHPeclipsePlugin.log(e);
3961   }
3962     label_30:
3963     while (true) {
3964       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3965       case CASE:
3966       case _DEFAULT:
3967         ;
3968         break;
3969       default:
3970         jj_la1[100] = jj_gen;
3971         break label_30;
3972       }
3973       cas = switchLabel0();
3974                           cases.add(cas);pos = cas.sourceEnd;
3975     }
3976     try {
3977       token = jj_consume_token(ENDSWITCH);
3978                          pos = token.sourceEnd;
3979     } catch (ParseException e) {
3980     errorMessage = "'endswitch' expected";
3981     errorLevel   = ERROR;
3982     errorStart = pos+1;
3983     errorEnd   = pos+1;
3984     processParseExceptionDebug(e);
3985     }
3986     try {
3987       token = jj_consume_token(SEMICOLON);
3988                          pos = token.sourceEnd;
3989     } catch (ParseException e) {
3990     errorMessage = "';' expected after 'endswitch' keyword";
3991     errorLevel   = ERROR;
3992     errorStart = pos+1;
3993     errorEnd   = pos+1;
3994     processParseExceptionDebug(e);
3995     }
3996     final AbstractCase[] abcase = new AbstractCase[cases.size()];
3997     cases.toArray(abcase);
3998     {if (true) return abcase;}
3999     throw new Error("Missing return statement in function");
4000   }
4001
4002   static final public AbstractCase switchLabel0() throws ParseException {
4003   final Expression expr;
4004   Statement statement;
4005   final ArrayList stmts = new ArrayList();
4006   final Token token = PHPParser.token;
4007   final int start = PHPParser.token.next.sourceStart;
4008     expr = SwitchLabel();
4009     label_31:
4010     while (true) {
4011       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
4012       case PHPEND:
4013       case CLASS:
4014       case FUNCTION:
4015       case IF:
4016       case ARRAY:
4017       case BREAK:
4018       case LIST:
4019       case PRINT:
4020       case ECHO:
4021       case INCLUDE:
4022       case REQUIRE:
4023       case INCLUDE_ONCE:
4024       case REQUIRE_ONCE:
4025       case GLOBAL:
4026       case DEFINE:
4027       case STATIC:
4028       case CONTINUE:
4029       case DO:
4030       case FOR:
4031       case NEW:
4032       case NULL:
4033       case RETURN:
4034       case SWITCH:
4035       case TRUE:
4036       case FALSE:
4037       case WHILE:
4038       case FOREACH:
4039       case AT:
4040       case BANG:
4041       case TILDE:
4042       case PLUS_PLUS:
4043       case MINUS_MINUS:
4044       case PLUS:
4045       case MINUS:
4046       case BIT_AND:
4047       case INTEGER_LITERAL:
4048       case FLOATING_POINT_LITERAL:
4049       case STRING_LITERAL:
4050       case DOUBLEQUOTE:
4051       case DOLLAR:
4052       case IDENTIFIER:
4053       case LPAREN:
4054       case LBRACE:
4055       case SEMICOLON:
4056         ;
4057         break;
4058       default:
4059         jj_la1[101] = jj_gen;
4060         break label_31;
4061       }
4062       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
4063       case CLASS:
4064       case FUNCTION:
4065       case IF:
4066       case ARRAY:
4067       case LIST:
4068       case PRINT:
4069       case ECHO:
4070       case INCLUDE:
4071       case REQUIRE:
4072       case INCLUDE_ONCE:
4073       case REQUIRE_ONCE:
4074       case GLOBAL:
4075       case DEFINE:
4076       case STATIC:
4077       case CONTINUE:
4078       case DO:
4079       case FOR:
4080       case NEW:
4081       case NULL:
4082       case RETURN:
4083       case SWITCH:
4084       case TRUE:
4085       case FALSE:
4086       case WHILE:
4087       case FOREACH:
4088       case AT:
4089       case BANG:
4090       case TILDE:
4091       case PLUS_PLUS:
4092       case MINUS_MINUS:
4093       case PLUS:
4094       case MINUS:
4095       case BIT_AND:
4096       case INTEGER_LITERAL:
4097       case FLOATING_POINT_LITERAL:
4098       case STRING_LITERAL:
4099       case DOUBLEQUOTE:
4100       case DOLLAR:
4101       case IDENTIFIER:
4102       case LPAREN:
4103       case LBRACE:
4104       case SEMICOLON:
4105         statement = BlockStatementNoBreak();
4106                                          stmts.add(statement);
4107         break;
4108       case PHPEND:
4109         statement = htmlBlock();
4110                                          if (statement != null) {stmts.add(statement);}
4111         break;
4112       case BREAK:
4113         statement = BreakStatement();
4114                                          stmts.add(statement);
4115         break;
4116       default:
4117         jj_la1[102] = jj_gen;
4118         jj_consume_token(-1);
4119         throw new ParseException();
4120       }
4121     }
4122     final int listSize = stmts.size();
4123     final Statement[] stmtsArray = new Statement[listSize];
4124     stmts.toArray(stmtsArray);
4125     if (expr == null) {//it's a default
4126       final int end = PHPParser.token.next.sourceStart;
4127       {if (true) return new DefaultCase(stmtsArray,start,end);}
4128     }
4129     if (listSize != 0) {
4130       {if (true) return new Case(expr,stmtsArray,expr.sourceStart,stmtsArray[listSize-1].sourceEnd);}
4131     } else {
4132       {if (true) return new Case(expr,stmtsArray,expr.sourceStart,expr.sourceEnd);}
4133     }
4134     throw new Error("Missing return statement in function");
4135   }
4136
4137 /**
4138  * A SwitchLabel.
4139  * case Expression() :
4140  * default :
4141  * @return the if it was a case and null if not
4142  */
4143   static final public Expression SwitchLabel() throws ParseException {
4144   final Expression expr;
4145     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
4146     case CASE:
4147       token = jj_consume_token(CASE);
4148       try {
4149         expr = Expression();
4150       } catch (ParseException e) {
4151     if (errorMessage != null) {if (true) throw e;}
4152     errorMessage = "expression expected after 'case' keyword";
4153     errorLevel   = ERROR;
4154     errorStart = token.sourceEnd +1;
4155     errorEnd   = token.sourceEnd +1;
4156     {if (true) throw e;}
4157       }
4158       try {
4159         token = jj_consume_token(COLON);
4160       } catch (ParseException e) {
4161     errorMessage = "':' expected after case expression";
4162     errorLevel   = ERROR;
4163     errorStart = expr.sourceEnd+1;
4164     errorEnd   = expr.sourceEnd+1;
4165     processParseExceptionDebug(e);
4166       }
4167    {if (true) return expr;}
4168       break;
4169     case _DEFAULT:
4170       token = jj_consume_token(_DEFAULT);
4171       try {
4172         jj_consume_token(COLON);
4173       } catch (ParseException e) {
4174     errorMessage = "':' expected after 'default' keyword";
4175     errorLevel   = ERROR;
4176     errorStart = token.sourceEnd+1;
4177     errorEnd   = token.sourceEnd+1;
4178     processParseExceptionDebug(e);
4179       }
4180    {if (true) return null;}
4181       break;
4182     default:
4183       jj_la1[103] = jj_gen;
4184       jj_consume_token(-1);
4185       throw new ParseException();
4186     }
4187     throw new Error("Missing return statement in function");
4188   }
4189
4190   static final public Break BreakStatement() throws ParseException {
4191   Expression expression = null;
4192   final Token token, token2;
4193   int pos;
4194     token = jj_consume_token(BREAK);
4195                    pos = token.sourceEnd+1;
4196     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
4197     case ARRAY:
4198     case LIST:
4199     case PRINT:
4200     case NEW:
4201     case NULL:
4202     case TRUE:
4203     case FALSE:
4204     case AT:
4205     case BANG:
4206     case TILDE:
4207     case PLUS_PLUS:
4208     case MINUS_MINUS:
4209     case PLUS:
4210     case MINUS:
4211     case BIT_AND:
4212     case INTEGER_LITERAL:
4213     case FLOATING_POINT_LITERAL:
4214     case STRING_LITERAL:
4215     case DOUBLEQUOTE:
4216     case DOLLAR:
4217     case IDENTIFIER:
4218     case LPAREN:
4219       expression = Expression();
4220                                pos = expression.sourceEnd+1;
4221       break;
4222     default:
4223       jj_la1[104] = jj_gen;
4224       ;
4225     }
4226     try {
4227       token2 = jj_consume_token(SEMICOLON);
4228      pos = token2.sourceEnd;
4229     } catch (ParseException e) {
4230     errorMessage = "';' expected after 'break' keyword";
4231     errorLevel   = ERROR;
4232     errorStart = pos;
4233     errorEnd   = pos;
4234     processParseExceptionDebug(e);
4235     }
4236    {if (true) return new Break(expression, token.sourceStart, pos);}
4237     throw new Error("Missing return statement in function");
4238   }
4239
4240   static final public IfStatement IfStatement() throws ParseException {
4241   final Expression condition;
4242   final IfStatement ifStatement;
4243   Token token;
4244     token = jj_consume_token(IF);
4245     condition = Condition("if");
4246     ifStatement = IfStatement0(condition,token.sourceStart,token.sourceEnd);
4247    {if (true) return ifStatement;}
4248     throw new Error("Missing return statement in function");
4249   }
4250
4251   static final public Expression Condition(final String keyword) throws ParseException {
4252   final Expression condition;
4253     try {
4254       jj_consume_token(LPAREN);
4255     } catch (ParseException e) {
4256     errorMessage = "'(' expected after " + keyword + " keyword";
4257     errorLevel   = ERROR;
4258     errorStart = PHPParser.token.sourceEnd + 1;
4259     errorEnd   = PHPParser.token.sourceEnd + 1;
4260     processParseExceptionDebug(e);
4261     }
4262     condition = Expression();
4263     try {
4264       jj_consume_token(RPAREN);
4265     } catch (ParseException e) {
4266     errorMessage = "')' expected after " + keyword + " keyword";
4267     errorLevel   = ERROR;
4268     errorStart = condition.sourceEnd+1;
4269     errorEnd   = condition.sourceEnd+1;
4270     processParseExceptionDebug(e);
4271     }
4272    {if (true) return condition;}
4273     throw new Error("Missing return statement in function");
4274   }
4275
4276   static final public IfStatement IfStatement0(final Expression condition, final int start,final int end) throws ParseException {
4277   Statement statement;
4278   final Statement stmt;
4279   final Statement[] statementsArray;
4280   ElseIf elseifStatement;
4281   Else elseStatement = null;
4282   final ArrayList stmts;
4283   final ArrayList elseIfList = new ArrayList();
4284   final ElseIf[] elseIfs;
4285   int pos = SimpleCharStream.getPosition();
4286   final int endStatements;
4287     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
4288     case COLON:
4289       jj_consume_token(COLON);
4290    stmts = new ArrayList();
4291       label_32:
4292       while (true) {
4293         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
4294         case PHPEND:
4295         case IF:
4296         case ARRAY:
4297         case BREAK:
4298         case LIST:
4299         case PRINT:
4300         case ECHO:
4301         case INCLUDE:
4302         case REQUIRE:
4303         case INCLUDE_ONCE:
4304         case REQUIRE_ONCE:
4305         case GLOBAL:
4306         case DEFINE:
4307         case STATIC:
4308         case CONTINUE:
4309         case DO:
4310         case FOR:
4311         case NEW:
4312         case NULL:
4313         case RETURN:
4314         case SWITCH:
4315         case TRUE:
4316         case FALSE:
4317         case WHILE:
4318         case FOREACH:
4319         case AT:
4320         case BANG:
4321         case TILDE:
4322         case PLUS_PLUS:
4323         case MINUS_MINUS:
4324         case PLUS:
4325         case MINUS:
4326         case BIT_AND:
4327         case INTEGER_LITERAL:
4328         case FLOATING_POINT_LITERAL:
4329         case STRING_LITERAL:
4330         case DOUBLEQUOTE:
4331         case DOLLAR:
4332         case IDENTIFIER:
4333         case LPAREN:
4334         case LBRACE:
4335         case SEMICOLON:
4336           ;
4337           break;
4338         default:
4339           jj_la1[105] = jj_gen;
4340           break label_32;
4341         }
4342         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
4343         case IF:
4344         case ARRAY:
4345         case BREAK:
4346         case LIST:
4347         case PRINT:
4348         case ECHO:
4349         case INCLUDE:
4350         case REQUIRE:
4351         case INCLUDE_ONCE:
4352         case REQUIRE_ONCE:
4353         case GLOBAL:
4354         case DEFINE:
4355         case STATIC:
4356         case CONTINUE:
4357         case DO:
4358         case FOR:
4359         case NEW:
4360         case NULL:
4361         case RETURN:
4362         case SWITCH:
4363         case TRUE:
4364         case FALSE:
4365         case WHILE:
4366         case FOREACH:
4367         case AT:
4368         case BANG:
4369         case TILDE:
4370         case PLUS_PLUS:
4371         case MINUS_MINUS:
4372         case PLUS:
4373         case MINUS:
4374         case BIT_AND:
4375         case INTEGER_LITERAL:
4376         case FLOATING_POINT_LITERAL:
4377         case STRING_LITERAL:
4378         case DOUBLEQUOTE:
4379         case DOLLAR:
4380         case IDENTIFIER:
4381         case LPAREN:
4382         case LBRACE:
4383         case SEMICOLON:
4384           statement = Statement();
4385                               stmts.add(statement);
4386           break;
4387         case PHPEND:
4388           statement = htmlBlock();
4389                               if (statement != null) {stmts.add(statement);}
4390           break;
4391         default:
4392           jj_la1[106] = jj_gen;
4393           jj_consume_token(-1);
4394           throw new ParseException();
4395         }
4396       }
4397     endStatements = SimpleCharStream.getPosition();
4398       label_33:
4399       while (true) {
4400         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
4401         case ELSEIF:
4402           ;
4403           break;
4404         default:
4405           jj_la1[107] = jj_gen;
4406           break label_33;
4407         }
4408         elseifStatement = ElseIfStatementColon();
4409                                               elseIfList.add(elseifStatement);
4410       }
4411       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
4412       case ELSE:
4413         elseStatement = ElseStatementColon();
4414         break;
4415       default:
4416         jj_la1[108] = jj_gen;
4417         ;
4418       }
4419    try {
4420   setMarker(fileToParse,
4421             "Ugly syntax detected, you should if () {...} instead of if (): ... endif;",
4422             start,
4423             end,
4424             INFO,
4425             "Line " + token.beginLine);
4426   } catch (CoreException e) {
4427     PHPeclipsePlugin.log(e);
4428   }
4429       try {
4430         jj_consume_token(ENDIF);
4431       } catch (ParseException e) {
4432     errorMessage = "'endif' expected";
4433     errorLevel   = ERROR;
4434     errorStart = e.currentToken.sourceStart;
4435     errorEnd   = e.currentToken.sourceEnd;
4436     {if (true) throw e;}
4437       }
4438       try {
4439         jj_consume_token(SEMICOLON);
4440       } catch (ParseException e) {
4441     errorMessage = "';' expected after 'endif' keyword";
4442     errorLevel   = ERROR;
4443     errorStart = e.currentToken.sourceStart;
4444     errorEnd   = e.currentToken.sourceEnd;
4445     {if (true) throw e;}
4446       }
4447     elseIfs = new ElseIf[elseIfList.size()];
4448     elseIfList.toArray(elseIfs);
4449     if (stmts.size() == 1) {
4450       {if (true) return new IfStatement(condition,
4451                              (Statement) stmts.get(0),
4452                               elseIfs,
4453                               elseStatement,
4454                               pos,
4455                               SimpleCharStream.getPosition());}
4456     } else {
4457       statementsArray = new Statement[stmts.size()];
4458       stmts.toArray(statementsArray);
4459       {if (true) return new IfStatement(condition,
4460                              new Block(statementsArray,pos,endStatements),
4461                              elseIfs,
4462                              elseStatement,
4463                              pos,
4464                              SimpleCharStream.getPosition());}
4465     }
4466       break;
4467     case PHPEND:
4468     case IF:
4469     case ARRAY:
4470     case BREAK:
4471     case LIST:
4472     case PRINT:
4473     case ECHO:
4474     case INCLUDE:
4475     case REQUIRE:
4476     case INCLUDE_ONCE:
4477     case REQUIRE_ONCE:
4478     case GLOBAL:
4479     case DEFINE:
4480     case STATIC:
4481     case CONTINUE:
4482     case DO:
4483     case FOR:
4484     case NEW:
4485     case NULL:
4486     case RETURN:
4487     case SWITCH:
4488     case TRUE:
4489     case FALSE:
4490     case WHILE:
4491     case FOREACH:
4492     case AT:
4493     case BANG:
4494     case TILDE:
4495     case PLUS_PLUS:
4496     case MINUS_MINUS:
4497     case PLUS:
4498     case MINUS:
4499     case BIT_AND:
4500     case INTEGER_LITERAL:
4501     case FLOATING_POINT_LITERAL:
4502     case STRING_LITERAL:
4503     case DOUBLEQUOTE:
4504     case DOLLAR:
4505     case IDENTIFIER:
4506     case LPAREN:
4507     case LBRACE:
4508     case SEMICOLON:
4509       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
4510       case IF:
4511       case ARRAY:
4512       case BREAK:
4513       case LIST:
4514       case PRINT:
4515       case ECHO:
4516       case INCLUDE:
4517       case REQUIRE:
4518       case INCLUDE_ONCE:
4519       case REQUIRE_ONCE:
4520       case GLOBAL:
4521       case DEFINE:
4522       case STATIC:
4523       case CONTINUE:
4524       case DO:
4525       case FOR:
4526       case NEW:
4527       case NULL:
4528       case RETURN:
4529       case SWITCH:
4530       case TRUE:
4531       case FALSE:
4532       case WHILE:
4533       case FOREACH:
4534       case AT:
4535       case BANG:
4536       case TILDE:
4537       case PLUS_PLUS:
4538       case MINUS_MINUS:
4539       case PLUS:
4540       case MINUS:
4541       case BIT_AND:
4542       case INTEGER_LITERAL:
4543       case FLOATING_POINT_LITERAL:
4544       case STRING_LITERAL:
4545       case DOUBLEQUOTE:
4546       case DOLLAR:
4547       case IDENTIFIER:
4548       case LPAREN:
4549       case LBRACE:
4550       case SEMICOLON:
4551         stmt = Statement();
4552         break;
4553       case PHPEND:
4554         stmt = htmlBlock();
4555         break;
4556       default:
4557         jj_la1[109] = jj_gen;
4558         jj_consume_token(-1);
4559         throw new ParseException();
4560       }
4561       label_34:
4562       while (true) {
4563         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
4564         case ELSEIF:
4565           ;
4566           break;
4567         default:
4568           jj_la1[110] = jj_gen;
4569           break label_34;
4570         }
4571         elseifStatement = ElseIfStatement();
4572                                                       elseIfList.add(elseifStatement);
4573       }
4574       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
4575       case ELSE:
4576         jj_consume_token(ELSE);
4577         try {
4578        pos = SimpleCharStream.getPosition();
4579           statement = Statement();
4580        elseStatement = new Else(statement,pos,SimpleCharStream.getPosition());
4581         } catch (ParseException e) {
4582       if (errorMessage != null) {
4583         {if (true) throw e;}
4584       }
4585       errorMessage = "unexpected token '"+e.currentToken.next.image+"', a statement was expected";
4586       errorLevel   = ERROR;
4587       errorStart = e.currentToken.sourceStart;
4588       errorEnd   = e.currentToken.sourceEnd;
4589       {if (true) throw e;}
4590         }
4591         break;
4592       default:
4593         jj_la1[111] = jj_gen;
4594         ;
4595       }
4596     elseIfs = new ElseIf[elseIfList.size()];
4597     elseIfList.toArray(elseIfs);
4598     {if (true) return new IfStatement(condition,
4599                            stmt,
4600                            elseIfs,
4601                            elseStatement,
4602                            pos,
4603                            SimpleCharStream.getPosition());}
4604       break;
4605     default:
4606       jj_la1[112] = jj_gen;
4607       jj_consume_token(-1);
4608       throw new ParseException();
4609     }
4610     throw new Error("Missing return statement in function");
4611   }
4612
4613   static final public ElseIf ElseIfStatementColon() throws ParseException {
4614   final Expression condition;
4615   Statement statement;
4616   final ArrayList list = new ArrayList();
4617   final Token elseifToken;
4618     elseifToken = jj_consume_token(ELSEIF);
4619     condition = Condition("elseif");
4620     jj_consume_token(COLON);
4621     label_35:
4622     while (true) {
4623       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
4624       case PHPEND:
4625       case IF:
4626       case ARRAY:
4627       case BREAK:
4628       case LIST:
4629       case PRINT:
4630       case ECHO:
4631       case INCLUDE:
4632       case REQUIRE:
4633       case INCLUDE_ONCE:
4634       case REQUIRE_ONCE:
4635       case GLOBAL:
4636       case DEFINE:
4637       case STATIC:
4638       case CONTINUE:
4639       case DO:
4640       case FOR:
4641       case NEW:
4642       case NULL:
4643       case RETURN:
4644       case SWITCH:
4645       case TRUE:
4646       case FALSE:
4647       case WHILE:
4648       case FOREACH:
4649       case AT:
4650       case BANG:
4651       case TILDE:
4652       case PLUS_PLUS:
4653       case MINUS_MINUS:
4654       case PLUS:
4655       case MINUS:
4656       case BIT_AND:
4657       case INTEGER_LITERAL:
4658       case FLOATING_POINT_LITERAL:
4659       case STRING_LITERAL:
4660       case DOUBLEQUOTE:
4661       case DOLLAR:
4662       case IDENTIFIER:
4663       case LPAREN:
4664       case LBRACE:
4665       case SEMICOLON:
4666         ;
4667         break;
4668       default:
4669         jj_la1[113] = jj_gen;
4670         break label_35;
4671       }
4672       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
4673       case IF:
4674       case ARRAY:
4675       case BREAK:
4676       case LIST:
4677       case PRINT:
4678       case ECHO:
4679       case INCLUDE:
4680       case REQUIRE:
4681       case INCLUDE_ONCE:
4682       case REQUIRE_ONCE:
4683       case GLOBAL:
4684       case DEFINE:
4685       case STATIC:
4686       case CONTINUE:
4687       case DO:
4688       case FOR:
4689       case NEW:
4690       case NULL:
4691       case RETURN:
4692       case SWITCH:
4693       case TRUE:
4694       case FALSE:
4695       case WHILE:
4696       case FOREACH:
4697       case AT:
4698       case BANG:
4699       case TILDE:
4700       case PLUS_PLUS:
4701       case MINUS_MINUS:
4702       case PLUS:
4703       case MINUS:
4704       case BIT_AND:
4705       case INTEGER_LITERAL:
4706       case FLOATING_POINT_LITERAL:
4707       case STRING_LITERAL:
4708       case DOUBLEQUOTE:
4709       case DOLLAR:
4710       case IDENTIFIER:
4711       case LPAREN:
4712       case LBRACE:
4713       case SEMICOLON:
4714         statement = Statement();
4715                                       list.add(statement);
4716         break;
4717       case PHPEND:
4718         statement = htmlBlock();
4719                                       if (statement != null) {list.add(statement);}
4720         break;
4721       default:
4722         jj_la1[114] = jj_gen;
4723         jj_consume_token(-1);
4724         throw new ParseException();
4725       }
4726     }
4727   final int sizeList = list.size();
4728   final Statement[] stmtsArray = new Statement[sizeList];
4729   list.toArray(stmtsArray);
4730   {if (true) return new ElseIf(condition,stmtsArray ,
4731                     elseifToken.sourceStart,
4732                     stmtsArray[sizeList-1].sourceEnd);}
4733     throw new Error("Missing return statement in function");
4734   }
4735
4736   static final public Else ElseStatementColon() throws ParseException {
4737   Statement statement;
4738   final ArrayList list = new ArrayList();
4739   final Token elseToken;
4740     elseToken = jj_consume_token(ELSE);
4741     jj_consume_token(COLON);
4742     label_36:
4743     while (true) {
4744       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
4745       case PHPEND:
4746       case IF:
4747       case ARRAY:
4748       case BREAK:
4749       case LIST:
4750       case PRINT:
4751       case ECHO:
4752       case INCLUDE:
4753       case REQUIRE:
4754       case INCLUDE_ONCE:
4755       case REQUIRE_ONCE:
4756       case GLOBAL:
4757       case DEFINE:
4758       case STATIC:
4759       case CONTINUE:
4760       case DO:
4761       case FOR:
4762       case NEW:
4763       case NULL:
4764       case RETURN:
4765       case SWITCH:
4766       case TRUE:
4767       case FALSE:
4768       case WHILE:
4769       case FOREACH:
4770       case AT:
4771       case BANG:
4772       case TILDE:
4773       case PLUS_PLUS:
4774       case MINUS_MINUS:
4775       case PLUS:
4776       case MINUS:
4777       case BIT_AND:
4778       case INTEGER_LITERAL:
4779       case FLOATING_POINT_LITERAL:
4780       case STRING_LITERAL:
4781       case DOUBLEQUOTE:
4782       case DOLLAR:
4783       case IDENTIFIER:
4784       case LPAREN:
4785       case LBRACE:
4786       case SEMICOLON:
4787         ;
4788         break;
4789       default:
4790         jj_la1[115] = jj_gen;
4791         break label_36;
4792       }
4793       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
4794       case IF:
4795       case ARRAY:
4796       case BREAK:
4797       case LIST:
4798       case PRINT:
4799       case ECHO:
4800       case INCLUDE:
4801       case REQUIRE:
4802       case INCLUDE_ONCE:
4803       case REQUIRE_ONCE:
4804       case GLOBAL:
4805       case DEFINE:
4806       case STATIC:
4807       case CONTINUE:
4808       case DO:
4809       case FOR:
4810       case NEW:
4811       case NULL:
4812       case RETURN:
4813       case SWITCH:
4814       case TRUE:
4815       case FALSE:
4816       case WHILE:
4817       case FOREACH:
4818       case AT:
4819       case BANG:
4820       case TILDE:
4821       case PLUS_PLUS:
4822       case MINUS_MINUS:
4823       case PLUS:
4824       case MINUS:
4825       case BIT_AND:
4826       case INTEGER_LITERAL:
4827       case FLOATING_POINT_LITERAL:
4828       case STRING_LITERAL:
4829       case DOUBLEQUOTE:
4830       case DOLLAR:
4831       case IDENTIFIER:
4832       case LPAREN:
4833       case LBRACE:
4834       case SEMICOLON:
4835         statement = Statement();
4836                                                          list.add(statement);
4837         break;
4838       case PHPEND:
4839         statement = htmlBlock();
4840                                              if (statement != null) {list.add(statement);}
4841         break;
4842       default:
4843         jj_la1[116] = jj_gen;
4844         jj_consume_token(-1);
4845         throw new ParseException();
4846       }
4847     }
4848   final int sizeList = list.size();
4849   final Statement[] stmtsArray = new Statement[sizeList];
4850   list.toArray(stmtsArray);
4851   {if (true) return new Else(stmtsArray,elseToken.sourceStart,stmtsArray[sizeList-1].sourceEnd);}
4852     throw new Error("Missing return statement in function");
4853   }
4854
4855   static final public ElseIf ElseIfStatement() throws ParseException {
4856   final Expression condition;
4857   //final Statement statement;
4858   final Token elseifToken;
4859   final Statement[] statement = new Statement[1];
4860     elseifToken = jj_consume_token(ELSEIF);
4861     condition = Condition("elseif");
4862     statement[0] = Statement();
4863   {if (true) return new ElseIf(condition,statement,elseifToken.sourceStart,statement[0].sourceEnd);}
4864     throw new Error("Missing return statement in function");
4865   }
4866
4867   static final public WhileStatement WhileStatement() throws ParseException {
4868   final Expression condition;
4869   final Statement action;
4870   final Token whileToken;
4871     whileToken = jj_consume_token(WHILE);
4872     condition = Condition("while");
4873     action = WhileStatement0(whileToken.sourceStart,whileToken.sourceEnd);
4874      {if (true) return new WhileStatement(condition,action,whileToken.sourceStart,action.sourceEnd);}
4875     throw new Error("Missing return statement in function");
4876   }
4877
4878   static final public Statement WhileStatement0(final int start, final int end) throws ParseException {
4879   Statement statement;
4880   final ArrayList stmts = new ArrayList();
4881   final int pos = SimpleCharStream.getPosition();
4882     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
4883     case COLON:
4884       jj_consume_token(COLON);
4885       label_37:
4886       while (true) {
4887         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
4888         case IF:
4889         case ARRAY:
4890         case BREAK:
4891         case LIST:
4892         case PRINT:
4893         case ECHO:
4894         case INCLUDE:
4895         case REQUIRE:
4896         case INCLUDE_ONCE:
4897         case REQUIRE_ONCE:
4898         case GLOBAL:
4899         case DEFINE:
4900         case STATIC:
4901         case CONTINUE:
4902         case DO:
4903         case FOR:
4904         case NEW:
4905         case NULL:
4906         case RETURN:
4907         case SWITCH:
4908         case TRUE:
4909         case FALSE:
4910         case WHILE:
4911         case FOREACH:
4912         case AT:
4913         case BANG:
4914         case TILDE:
4915         case PLUS_PLUS:
4916         case MINUS_MINUS:
4917         case PLUS:
4918         case MINUS:
4919         case BIT_AND:
4920         case INTEGER_LITERAL:
4921         case FLOATING_POINT_LITERAL:
4922         case STRING_LITERAL:
4923         case DOUBLEQUOTE:
4924         case DOLLAR:
4925         case IDENTIFIER:
4926         case LPAREN:
4927         case LBRACE:
4928         case SEMICOLON:
4929           ;
4930           break;
4931         default:
4932           jj_la1[117] = jj_gen;
4933           break label_37;
4934         }
4935         statement = Statement();
4936                                     stmts.add(statement);
4937       }
4938    try {
4939   setMarker(fileToParse,
4940             "Ugly syntax detected, you should while () {...} instead of while (): ... endwhile;",
4941             start,
4942             end,
4943             INFO,
4944             "Line " + token.beginLine);
4945   } catch (CoreException e) {
4946     PHPeclipsePlugin.log(e);
4947   }
4948       try {
4949         jj_consume_token(ENDWHILE);
4950       } catch (ParseException e) {
4951     errorMessage = "'endwhile' expected";
4952     errorLevel   = ERROR;
4953     errorStart = e.currentToken.sourceStart;
4954     errorEnd   = e.currentToken.sourceEnd;
4955     {if (true) throw e;}
4956       }
4957       try {
4958         jj_consume_token(SEMICOLON);
4959     final Statement[] stmtsArray = new Statement[stmts.size()];
4960     stmts.toArray(stmtsArray);
4961     {if (true) return new Block(stmtsArray,pos,SimpleCharStream.getPosition());}
4962       } catch (ParseException e) {
4963     errorMessage = "';' expected after 'endwhile' keyword";
4964     errorLevel   = ERROR;
4965     errorStart = e.currentToken.sourceStart;
4966     errorEnd   = e.currentToken.sourceEnd;
4967     {if (true) throw e;}
4968       }
4969       break;
4970     case IF:
4971     case ARRAY:
4972     case BREAK:
4973     case LIST:
4974     case PRINT:
4975     case ECHO:
4976     case INCLUDE:
4977     case REQUIRE:
4978     case INCLUDE_ONCE:
4979     case REQUIRE_ONCE:
4980     case GLOBAL:
4981     case DEFINE:
4982     case STATIC:
4983     case CONTINUE:
4984     case DO:
4985     case FOR:
4986     case NEW:
4987     case NULL:
4988     case RETURN:
4989     case SWITCH:
4990     case TRUE:
4991     case FALSE:
4992     case WHILE:
4993     case FOREACH:
4994     case AT:
4995     case BANG:
4996     case TILDE:
4997     case PLUS_PLUS:
4998     case MINUS_MINUS:
4999     case PLUS:
5000     case MINUS:
5001     case BIT_AND:
5002     case INTEGER_LITERAL:
5003     case FLOATING_POINT_LITERAL:
5004     case STRING_LITERAL:
5005     case DOUBLEQUOTE:
5006     case DOLLAR:
5007     case IDENTIFIER:
5008     case LPAREN:
5009     case LBRACE:
5010     case SEMICOLON:
5011       statement = Statement();
5012    {if (true) return statement;}
5013       break;
5014     default:
5015       jj_la1[118] = jj_gen;
5016       jj_consume_token(-1);
5017       throw new ParseException();
5018     }
5019     throw new Error("Missing return statement in function");
5020   }
5021
5022   static final public DoStatement DoStatement() throws ParseException {
5023   final Statement action;
5024   final Expression condition;
5025   final Token token;
5026   Token token2 = null;
5027     token = jj_consume_token(DO);
5028     action = Statement();
5029     jj_consume_token(WHILE);
5030     condition = Condition("while");
5031     try {
5032       token2 = jj_consume_token(SEMICOLON);
5033     } catch (ParseException e) {
5034     errorMessage = "unexpected token : '"+ e.currentToken.next.image +"'. A ';' was expected";
5035     errorLevel   = ERROR;
5036     errorStart = condition.sourceEnd+1;
5037     errorEnd   = condition.sourceEnd+1;
5038     processParseExceptionDebug(e);
5039     }
5040     if (token2 == null) {
5041       {if (true) return new DoStatement(condition,action,token.sourceStart,condition.sourceEnd);}
5042     }
5043     {if (true) return new DoStatement(condition,action,token.sourceStart,token2.sourceEnd);}
5044     throw new Error("Missing return statement in function");
5045   }
5046
5047   static final public ForeachStatement ForeachStatement() throws ParseException {
5048   Statement statement = null;
5049   Expression expression = null;
5050   ArrayVariableDeclaration variable = null;
5051   Token foreachToken;
5052   Token lparenToken = null;
5053   Token asToken = null;
5054   Token rparenToken = null;
5055   int pos;
5056     foreachToken = jj_consume_token(FOREACH);
5057     try {
5058       lparenToken = jj_consume_token(LPAREN);
5059      pos = lparenToken.sourceEnd+1;
5060     } catch (ParseException e) {
5061     errorMessage = "'(' expected after 'foreach' keyword";
5062     errorLevel   = ERROR;
5063     errorStart = e.currentToken.sourceStart;
5064     errorEnd   = e.currentToken.sourceEnd;
5065     processParseExceptionDebug(e);
5066     {pos = foreachToken.sourceEnd+1;}
5067     }
5068     try {
5069       expression = Expression();
5070      pos = expression.sourceEnd+1;
5071     } catch (ParseException e) {
5072     errorMessage = "variable expected";
5073     errorLevel   = ERROR;
5074     errorStart = e.currentToken.sourceStart;
5075     errorEnd   = e.currentToken.sourceEnd;
5076     processParseExceptionDebug(e);
5077     }
5078     try {
5079       asToken = jj_consume_token(AS);
5080      pos = asToken.sourceEnd+1;
5081     } catch (ParseException e) {
5082     errorMessage = "'as' expected";
5083     errorLevel   = ERROR;
5084     errorStart = e.currentToken.sourceStart;
5085     errorEnd   = e.currentToken.sourceEnd;
5086     processParseExceptionDebug(e);
5087     }
5088     try {
5089       variable = ArrayVariable();
5090      pos = variable.sourceEnd+1;
5091     } catch (ParseException e) {
5092     if (errorMessage != null) {if (true) throw e;}
5093     errorMessage = "variable expected";
5094     errorLevel   = ERROR;
5095     errorStart = e.currentToken.sourceStart;
5096     errorEnd   = e.currentToken.sourceEnd;
5097     processParseExceptionDebug(e);
5098     }
5099     try {
5100       rparenToken = jj_consume_token(RPAREN);
5101      pos = rparenToken.sourceEnd+1;
5102     } catch (ParseException e) {
5103     errorMessage = "')' expected after 'foreach' keyword";
5104     errorLevel   = ERROR;
5105     errorStart = e.currentToken.sourceStart;
5106     errorEnd   = e.currentToken.sourceEnd;
5107     processParseExceptionDebug(e);
5108     }
5109     try {
5110       statement = Statement();
5111      pos = statement.sourceEnd+1;
5112     } catch (ParseException e) {
5113     if (errorMessage != null) {if (true) throw e;}
5114     errorMessage = "statement expected";
5115     errorLevel   = ERROR;
5116     errorStart = e.currentToken.sourceStart;
5117     errorEnd   = e.currentToken.sourceEnd;
5118     processParseExceptionDebug(e);
5119     }
5120    {if (true) return new ForeachStatement(expression,
5121                                variable,
5122                                statement,
5123                                foreachToken.sourceStart,
5124                                pos);}
5125     throw new Error("Missing return statement in function");
5126   }
5127
5128 /**
5129  * a for declaration.
5130  * @return a node representing the for statement
5131  */
5132   static final public ForStatement ForStatement() throws ParseException {
5133 final Token token,tokenEndFor,token2,tokenColon;
5134 int pos;
5135 Expression[] initializations = null;
5136 Expression condition = null;
5137 Expression[] increments = null;
5138 Statement action;
5139 final ArrayList list = new ArrayList();
5140     token = jj_consume_token(FOR);
5141     try {
5142       jj_consume_token(LPAREN);
5143     } catch (ParseException e) {
5144     errorMessage = "'(' expected after 'for' keyword";
5145     errorLevel   = ERROR;
5146     errorStart = token.sourceEnd;
5147     errorEnd   = token.sourceEnd +1;
5148     processParseExceptionDebug(e);
5149     }
5150     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
5151     case ARRAY:
5152     case LIST:
5153     case PRINT:
5154     case NEW:
5155     case NULL:
5156     case TRUE:
5157     case FALSE:
5158     case AT:
5159     case BANG:
5160     case TILDE:
5161     case PLUS_PLUS:
5162     case MINUS_MINUS:
5163     case PLUS:
5164     case MINUS:
5165     case BIT_AND:
5166     case INTEGER_LITERAL:
5167     case FLOATING_POINT_LITERAL:
5168     case STRING_LITERAL:
5169     case DOUBLEQUOTE:
5170     case DOLLAR:
5171     case IDENTIFIER:
5172     case LPAREN:
5173       initializations = ForInit();
5174       break;
5175     default:
5176       jj_la1[119] = jj_gen;
5177       ;
5178     }
5179     jj_consume_token(SEMICOLON);
5180     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
5181     case ARRAY:
5182     case LIST:
5183     case PRINT:
5184     case NEW:
5185     case NULL:
5186     case TRUE:
5187     case FALSE:
5188     case AT:
5189     case BANG:
5190     case TILDE:
5191     case PLUS_PLUS:
5192     case MINUS_MINUS:
5193     case PLUS:
5194     case MINUS:
5195     case BIT_AND:
5196     case INTEGER_LITERAL:
5197     case FLOATING_POINT_LITERAL:
5198     case STRING_LITERAL:
5199     case DOUBLEQUOTE:
5200     case DOLLAR:
5201     case IDENTIFIER:
5202     case LPAREN:
5203       condition = Expression();
5204       break;
5205     default:
5206       jj_la1[120] = jj_gen;
5207       ;
5208     }
5209     jj_consume_token(SEMICOLON);
5210     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
5211     case ARRAY:
5212     case LIST:
5213     case PRINT:
5214     case NEW:
5215     case NULL:
5216     case TRUE:
5217     case FALSE:
5218     case AT:
5219     case BANG:
5220     case TILDE:
5221     case PLUS_PLUS:
5222     case MINUS_MINUS:
5223     case PLUS:
5224     case MINUS:
5225     case BIT_AND:
5226     case INTEGER_LITERAL:
5227     case FLOATING_POINT_LITERAL:
5228     case STRING_LITERAL:
5229     case DOUBLEQUOTE:
5230     case DOLLAR:
5231     case IDENTIFIER:
5232     case LPAREN:
5233       increments = StatementExpressionList();
5234       break;
5235     default:
5236       jj_la1[121] = jj_gen;
5237       ;
5238     }
5239     jj_consume_token(RPAREN);
5240     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
5241     case IF:
5242     case ARRAY:
5243     case BREAK:
5244     case LIST:
5245     case PRINT:
5246     case ECHO:
5247     case INCLUDE:
5248     case REQUIRE:
5249     case INCLUDE_ONCE:
5250     case REQUIRE_ONCE:
5251     case GLOBAL:
5252     case DEFINE:
5253     case STATIC:
5254     case CONTINUE:
5255     case DO:
5256     case FOR:
5257     case NEW:
5258     case NULL:
5259     case RETURN:
5260     case SWITCH:
5261     case TRUE:
5262     case FALSE:
5263     case WHILE:
5264     case FOREACH:
5265     case AT:
5266     case BANG:
5267     case TILDE:
5268     case PLUS_PLUS:
5269     case MINUS_MINUS:
5270     case PLUS:
5271     case MINUS:
5272     case BIT_AND:
5273     case INTEGER_LITERAL:
5274     case FLOATING_POINT_LITERAL:
5275     case STRING_LITERAL:
5276     case DOUBLEQUOTE:
5277     case DOLLAR:
5278     case IDENTIFIER:
5279     case LPAREN:
5280     case LBRACE:
5281     case SEMICOLON:
5282       action = Statement();
5283        {if (true) return new ForStatement(initializations,
5284                                condition,
5285                                increments,
5286                                action,
5287                                token.sourceStart,
5288                                action.sourceEnd);}
5289       break;
5290     case COLON:
5291       tokenColon = jj_consume_token(COLON);
5292                             pos = tokenColon.sourceEnd+1;
5293       label_38:
5294       while (true) {
5295         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
5296         case IF:
5297         case ARRAY:
5298         case BREAK:
5299         case LIST:
5300         case PRINT:
5301         case ECHO:
5302         case INCLUDE:
5303         case REQUIRE:
5304         case INCLUDE_ONCE:
5305         case REQUIRE_ONCE:
5306         case GLOBAL:
5307         case DEFINE:
5308         case STATIC:
5309         case CONTINUE:
5310         case DO:
5311         case FOR:
5312         case NEW:
5313         case NULL:
5314         case RETURN:
5315         case SWITCH:
5316         case TRUE:
5317         case FALSE:
5318         case WHILE:
5319         case FOREACH:
5320         case AT:
5321         case BANG:
5322         case TILDE:
5323         case PLUS_PLUS:
5324         case MINUS_MINUS:
5325         case PLUS:
5326         case MINUS:
5327         case BIT_AND:
5328         case INTEGER_LITERAL:
5329         case FLOATING_POINT_LITERAL:
5330         case STRING_LITERAL:
5331         case DOUBLEQUOTE:
5332         case DOLLAR:
5333         case IDENTIFIER:
5334         case LPAREN:
5335         case LBRACE:
5336         case SEMICOLON:
5337           ;
5338           break;
5339         default:
5340           jj_la1[122] = jj_gen;
5341           break label_38;
5342         }
5343         action = Statement();
5344                              list.add(action);pos = action.sourceEnd+1;
5345       }
5346         try {
5347         setMarker(fileToParse,
5348                   "Ugly syntax detected, you should for () {...} instead of for (): ... endfor;",
5349                   token.sourceStart,
5350                   token.sourceEnd,
5351                   INFO,
5352                   "Line " + token.beginLine);
5353         } catch (CoreException e) {
5354           PHPeclipsePlugin.log(e);
5355         }
5356       try {
5357         tokenEndFor = jj_consume_token(ENDFOR);
5358          pos = tokenEndFor.sourceEnd+1;
5359       } catch (ParseException e) {
5360         errorMessage = "'endfor' expected";
5361         errorLevel   = ERROR;
5362         errorStart = pos;
5363         errorEnd   = pos;
5364         processParseExceptionDebug(e);
5365       }
5366       try {
5367         token2 = jj_consume_token(SEMICOLON);
5368          pos = token2.sourceEnd+1;
5369       } catch (ParseException e) {
5370         errorMessage = "';' expected after 'endfor' keyword";
5371         errorLevel   = ERROR;
5372         errorStart = pos;
5373         errorEnd   = pos;
5374         processParseExceptionDebug(e);
5375       }
5376       final Statement[] stmtsArray = new Statement[list.size()];
5377       list.toArray(stmtsArray);
5378       {if (true) return new ForStatement(initializations,
5379                               condition,
5380                               increments,
5381                               new Block(stmtsArray,
5382                                         stmtsArray[0].sourceStart,
5383                                         stmtsArray[stmtsArray.length-1].sourceEnd),
5384                               token.sourceStart,
5385                               pos);}
5386       break;
5387     default:
5388       jj_la1[123] = jj_gen;
5389       jj_consume_token(-1);
5390       throw new ParseException();
5391     }
5392     throw new Error("Missing return statement in function");
5393   }
5394
5395   static final public Expression[] ForInit() throws ParseException {
5396   final Expression[] exprs;
5397     if (jj_2_5(2147483647)) {
5398       exprs = LocalVariableDeclaration();
5399    {if (true) return exprs;}
5400     } else {
5401       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
5402       case ARRAY:
5403       case LIST:
5404       case PRINT:
5405       case NEW:
5406       case NULL:
5407       case TRUE:
5408       case FALSE:
5409       case AT:
5410       case BANG:
5411       case TILDE:
5412       case PLUS_PLUS:
5413       case MINUS_MINUS:
5414       case PLUS:
5415       case MINUS:
5416       case BIT_AND:
5417       case INTEGER_LITERAL:
5418       case FLOATING_POINT_LITERAL:
5419       case STRING_LITERAL:
5420       case DOUBLEQUOTE:
5421       case DOLLAR:
5422       case IDENTIFIER:
5423       case LPAREN:
5424         exprs = StatementExpressionList();
5425    {if (true) return exprs;}
5426         break;
5427       default:
5428         jj_la1[124] = jj_gen;
5429         jj_consume_token(-1);
5430         throw new ParseException();
5431       }
5432     }
5433     throw new Error("Missing return statement in function");
5434   }
5435
5436   static final public Expression[] StatementExpressionList() throws ParseException {
5437   final ArrayList list = new ArrayList();
5438   final Expression expr;
5439     expr = Expression();
5440                          list.add(expr);
5441     label_39:
5442     while (true) {
5443       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
5444       case COMMA:
5445         ;
5446         break;
5447       default:
5448         jj_la1[125] = jj_gen;
5449         break label_39;
5450       }
5451       jj_consume_token(COMMA);
5452       Expression();
5453                          list.add(expr);
5454     }
5455     final Expression[] exprsArray = new Expression[list.size()];
5456     list.toArray(exprsArray);
5457     {if (true) return exprsArray;}
5458     throw new Error("Missing return statement in function");
5459   }
5460
5461   static final public Continue ContinueStatement() throws ParseException {
5462   Expression expr = null;
5463   final Token token;
5464   Token token2 = null;
5465     token = jj_consume_token(CONTINUE);
5466     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
5467     case ARRAY:
5468     case LIST:
5469     case PRINT:
5470     case NEW:
5471     case NULL:
5472     case TRUE:
5473     case FALSE:
5474     case AT:
5475     case BANG:
5476     case TILDE:
5477     case PLUS_PLUS:
5478     case MINUS_MINUS:
5479     case PLUS:
5480     case MINUS:
5481     case BIT_AND:
5482     case INTEGER_LITERAL:
5483     case FLOATING_POINT_LITERAL:
5484     case STRING_LITERAL:
5485     case DOUBLEQUOTE:
5486     case DOLLAR:
5487     case IDENTIFIER:
5488     case LPAREN:
5489       expr = Expression();
5490       break;
5491     default:
5492       jj_la1[126] = jj_gen;
5493       ;
5494     }
5495     try {
5496       token2 = jj_consume_token(SEMICOLON);
5497     } catch (ParseException e) {
5498     errorMessage = "';' expected after 'continue' statement";
5499     errorLevel   = ERROR;
5500     if (expr == null) {
5501       errorStart = token.sourceEnd+1;
5502       errorEnd   = token.sourceEnd+1;
5503     } else {
5504       errorStart = expr.sourceEnd+1;
5505       errorEnd   = expr.sourceEnd+1;
5506     }
5507     processParseExceptionDebug(e);
5508     }
5509     if (token2 == null) {
5510       if (expr == null) {
5511         {if (true) return new Continue(expr,token.sourceStart,token.sourceEnd);}
5512       }
5513       {if (true) return new Continue(expr,token.sourceStart,expr.sourceEnd);}
5514     }
5515     {if (true) return new Continue(expr,token.sourceStart,token2.sourceEnd);}
5516     throw new Error("Missing return statement in function");
5517   }
5518
5519   static final public ReturnStatement ReturnStatement() throws ParseException {
5520   Expression expr = null;
5521   final Token token;
5522   Token token2 = null;
5523     token = jj_consume_token(RETURN);
5524     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
5525     case ARRAY:
5526     case LIST:
5527     case PRINT:
5528     case NEW:
5529     case NULL:
5530     case TRUE:
5531     case FALSE:
5532     case AT:
5533     case BANG:
5534     case TILDE:
5535     case PLUS_PLUS:
5536     case MINUS_MINUS:
5537     case PLUS:
5538     case MINUS:
5539     case BIT_AND:
5540     case INTEGER_LITERAL:
5541     case FLOATING_POINT_LITERAL:
5542     case STRING_LITERAL:
5543     case DOUBLEQUOTE:
5544     case DOLLAR:
5545     case IDENTIFIER:
5546     case LPAREN:
5547       expr = Expression();
5548       break;
5549     default:
5550       jj_la1[127] = jj_gen;
5551       ;
5552     }
5553     try {
5554       token2 = jj_consume_token(SEMICOLON);
5555     } catch (ParseException e) {
5556     errorMessage = "';' expected after 'return' statement";
5557     errorLevel   = ERROR;
5558     if (expr == null) {
5559       errorStart = token.sourceEnd+1;
5560       errorEnd   = token.sourceEnd+1;
5561     } else {
5562       errorStart = expr.sourceEnd+1;
5563       errorEnd   = expr.sourceEnd+1;
5564     }
5565     processParseExceptionDebug(e);
5566     }
5567     if (token2 == null) {
5568       if (expr == null) {
5569         {if (true) return new ReturnStatement(expr,token.sourceStart,token.sourceEnd);}
5570       }
5571       {if (true) return new ReturnStatement(expr,token.sourceStart,expr.sourceEnd);}
5572     }
5573     {if (true) return new ReturnStatement(expr,token.sourceStart,token2.sourceEnd);}
5574     throw new Error("Missing return statement in function");
5575   }
5576
5577   static final private boolean jj_2_1(int xla) {
5578     jj_la = xla; jj_lastpos = jj_scanpos = token;
5579     boolean retval = !jj_3_1();
5580     jj_save(0, xla);
5581     return retval;
5582   }
5583
5584   static final private boolean jj_2_2(int xla) {
5585     jj_la = xla; jj_lastpos = jj_scanpos = token;
5586     boolean retval = !jj_3_2();
5587     jj_save(1, xla);
5588     return retval;
5589   }
5590
5591   static final private boolean jj_2_3(int xla) {
5592     jj_la = xla; jj_lastpos = jj_scanpos = token;
5593     boolean retval = !jj_3_3();
5594     jj_save(2, xla);
5595     return retval;
5596   }
5597
5598   static final private boolean jj_2_4(int xla) {
5599     jj_la = xla; jj_lastpos = jj_scanpos = token;
5600     boolean retval = !jj_3_4();
5601     jj_save(3, xla);
5602     return retval;
5603   }
5604
5605   static final private boolean jj_2_5(int xla) {
5606     jj_la = xla; jj_lastpos = jj_scanpos = token;
5607     boolean retval = !jj_3_5();
5608     jj_save(4, xla);
5609     return retval;
5610   }
5611
5612   static final private boolean jj_3R_210() {
5613     if (jj_3R_116()) return true;
5614     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5615     return false;
5616   }
5617
5618   static final private boolean jj_3R_209() {
5619     if (jj_3R_50()) return true;
5620     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5621     return false;
5622   }
5623
5624   static final private boolean jj_3R_109() {
5625     if (jj_3R_114()) return true;
5626     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5627     Token xsp;
5628     while (true) {
5629       xsp = jj_scanpos;
5630       if (jj_3R_115()) { jj_scanpos = xsp; break; }
5631       if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5632     }
5633     return false;
5634   }
5635
5636   static final private boolean jj_3R_208() {
5637     if (jj_scan_token(IDENTIFIER)) return true;
5638     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5639     return false;
5640   }
5641
5642   static final private boolean jj_3R_203() {
5643     Token xsp;
5644     xsp = jj_scanpos;
5645     if (jj_3R_208()) {
5646     jj_scanpos = xsp;
5647     if (jj_3R_209()) {
5648     jj_scanpos = xsp;
5649     if (jj_3R_210()) return true;
5650     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5651     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5652     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5653     return false;
5654   }
5655
5656   static final private boolean jj_3R_110() {
5657     if (jj_scan_token(BIT_OR)) return true;
5658     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5659     if (jj_3R_109()) return true;
5660     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5661     return false;
5662   }
5663
5664   static final private boolean jj_3R_103() {
5665     if (jj_3R_109()) return true;
5666     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5667     Token xsp;
5668     while (true) {
5669       xsp = jj_scanpos;
5670       if (jj_3R_110()) { jj_scanpos = xsp; break; }
5671       if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5672     }
5673     return false;
5674   }
5675
5676   static final private boolean jj_3R_188() {
5677     if (jj_scan_token(ARRAY)) return true;
5678     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5679     if (jj_3R_198()) return true;
5680     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5681     return false;
5682   }
5683
5684   static final private boolean jj_3R_132() {
5685     if (jj_scan_token(IDENTIFIER)) return true;
5686     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5687     return false;
5688   }
5689
5690   static final private boolean jj_3R_106() {
5691     if (jj_scan_token(DOT)) return true;
5692     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5693     if (jj_3R_103()) return true;
5694     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5695     return false;
5696   }
5697
5698   static final private boolean jj_3R_131() {
5699     if (jj_scan_token(LBRACE)) return true;
5700     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5701     if (jj_3R_49()) return true;
5702     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5703     if (jj_scan_token(RBRACE)) return true;
5704     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5705     return false;
5706   }
5707
5708   static final private boolean jj_3R_97() {
5709     if (jj_3R_103()) return true;
5710     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5711     Token xsp;
5712     while (true) {
5713       xsp = jj_scanpos;
5714       if (jj_3R_106()) { jj_scanpos = xsp; break; }
5715       if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5716     }
5717     return false;
5718   }
5719
5720   static final private boolean jj_3R_204() {
5721     if (jj_3R_207()) return true;
5722     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5723     return false;
5724   }
5725
5726   static final private boolean jj_3R_122() {
5727     Token xsp;
5728     xsp = jj_scanpos;
5729     if (jj_3R_130()) {
5730     jj_scanpos = xsp;
5731     if (jj_3R_131()) {
5732     jj_scanpos = xsp;
5733     if (jj_3R_132()) return true;
5734     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5735     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5736     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5737     return false;
5738   }
5739
5740   static final private boolean jj_3R_130() {
5741     if (jj_scan_token(DOLLAR)) return true;
5742     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5743     if (jj_3R_122()) return true;
5744     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5745     return false;
5746   }
5747
5748   static final private boolean jj_3R_108() {
5749     if (jj_scan_token(_ANDL)) return true;
5750     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5751     return false;
5752   }
5753
5754   static final private boolean jj_3R_107() {
5755     if (jj_scan_token(AND_AND)) return true;
5756     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5757     return false;
5758   }
5759
5760   static final private boolean jj_3R_100() {
5761     Token xsp;
5762     xsp = jj_scanpos;
5763     if (jj_3R_107()) {
5764     jj_scanpos = xsp;
5765     if (jj_3R_108()) return true;
5766     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5767     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5768     if (jj_3R_97()) 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_81() {
5774     if (jj_3R_97()) return true;
5775     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5776     Token xsp;
5777     while (true) {
5778       xsp = jj_scanpos;
5779       if (jj_3R_100()) { jj_scanpos = xsp; break; }
5780       if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5781     }
5782     return false;
5783   }
5784
5785   static final private boolean jj_3R_79() {
5786     if (jj_scan_token(HOOK)) return true;
5787     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5788     if (jj_3R_49()) return true;
5789     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5790     if (jj_scan_token(COLON)) return true;
5791     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5792     if (jj_3R_73()) return true;
5793     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5794     return false;
5795   }
5796
5797   static final private boolean jj_3R_195() {
5798     if (jj_scan_token(NEW)) return true;
5799     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5800     if (jj_3R_203()) return true;
5801     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5802     Token xsp;
5803     xsp = jj_scanpos;
5804     if (jj_3R_204()) jj_scanpos = xsp;
5805     else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5806     return false;
5807   }
5808
5809   static final private boolean jj_3R_68() {
5810     if (jj_scan_token(DOLLAR)) return true;
5811     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5812     if (jj_3R_122()) return true;
5813     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5814     return false;
5815   }
5816
5817   static final private boolean jj_3R_202() {
5818     if (jj_3R_207()) return true;
5819     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5820     return false;
5821   }
5822
5823   static final private boolean jj_3R_194() {
5824     if (jj_3R_116()) return true;
5825     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5826     Token xsp;
5827     xsp = jj_scanpos;
5828     if (jj_3R_202()) jj_scanpos = xsp;
5829     else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5830     return false;
5831   }
5832
5833   static final private boolean jj_3R_102() {
5834     if (jj_scan_token(_ORL)) return true;
5835     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5836     return false;
5837   }
5838
5839   static final private boolean jj_3R_101() {
5840     if (jj_scan_token(OR_OR)) return true;
5841     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5842     return false;
5843   }
5844
5845   static final private boolean jj_3R_83() {
5846     Token xsp;
5847     xsp = jj_scanpos;
5848     if (jj_3R_101()) {
5849     jj_scanpos = xsp;
5850     if (jj_3R_102()) return true;
5851     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5852     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5853     if (jj_3R_81()) return true;
5854     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5855     return false;
5856   }
5857
5858   static final private boolean jj_3R_201() {
5859     if (jj_3R_207()) return true;
5860     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5861     return false;
5862   }
5863
5864   static final private boolean jj_3R_76() {
5865     if (jj_3R_81()) return true;
5866     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5867     Token xsp;
5868     while (true) {
5869       xsp = jj_scanpos;
5870       if (jj_3R_83()) { jj_scanpos = xsp; break; }
5871       if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5872     }
5873     return false;
5874   }
5875
5876   static final private boolean jj_3_1() {
5877     if (jj_3R_40()) return true;
5878     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5879     return false;
5880   }
5881
5882   static final private boolean jj_3R_51() {
5883     if (jj_scan_token(COMMA)) return true;
5884     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5885     if (jj_3R_49()) return true;
5886     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5887     return false;
5888   }
5889
5890   static final private boolean jj_3R_200() {
5891     if (jj_scan_token(STATICCLASSACCESS)) return true;
5892     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5893     if (jj_3R_203()) return true;
5894     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5895     return false;
5896   }
5897
5898   static final private boolean jj_3R_45() {
5899     if (jj_3R_49()) return true;
5900     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5901     Token xsp;
5902     while (true) {
5903       xsp = jj_scanpos;
5904       if (jj_3R_51()) { jj_scanpos = xsp; break; }
5905       if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5906     }
5907     return false;
5908   }
5909
5910   static final private boolean jj_3R_116() {
5911     if (jj_3R_68()) return true;
5912     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5913     Token xsp;
5914     while (true) {
5915       xsp = jj_scanpos;
5916       if (jj_3_1()) { jj_scanpos = xsp; break; }
5917       if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5918     }
5919     return false;
5920   }
5921
5922   static final private boolean jj_3R_193() {
5923     if (jj_scan_token(IDENTIFIER)) return true;
5924     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5925     Token xsp;
5926     while (true) {
5927       xsp = jj_scanpos;
5928       if (jj_3R_200()) { jj_scanpos = xsp; break; }
5929       if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5930     }
5931     xsp = jj_scanpos;
5932     if (jj_3R_201()) jj_scanpos = xsp;
5933     else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5934     return false;
5935   }
5936
5937   static final private boolean jj_3R_187() {
5938     Token xsp;
5939     xsp = jj_scanpos;
5940     if (jj_3R_193()) {
5941     jj_scanpos = xsp;
5942     if (jj_3R_194()) {
5943     jj_scanpos = xsp;
5944     if (jj_3R_195()) return true;
5945     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5946     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5947     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5948     return false;
5949   }
5950
5951   static final private boolean jj_3R_73() {
5952     if (jj_3R_76()) return true;
5953     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5954     Token xsp;
5955     xsp = jj_scanpos;
5956     if (jj_3R_79()) jj_scanpos = xsp;
5957     else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5958     return false;
5959   }
5960
5961   static final private boolean jj_3R_178() {
5962     if (jj_3R_188()) return true;
5963     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5964     return false;
5965   }
5966
5967   static final private boolean jj_3_5() {
5968     if (jj_3R_45()) return true;
5969     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5970     return false;
5971   }
5972
5973   static final private boolean jj_3R_186() {
5974     if (jj_scan_token(BIT_AND)) return true;
5975     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5976     return false;
5977   }
5978
5979   static final private boolean jj_3R_96() {
5980     if (jj_scan_token(TILDEEQUAL)) return true;
5981     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5982     return false;
5983   }
5984
5985   static final private boolean jj_3R_95() {
5986     if (jj_scan_token(DOTASSIGN)) return true;
5987     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5988     return false;
5989   }
5990
5991   static final private boolean jj_3R_173() {
5992     Token xsp;
5993     xsp = jj_scanpos;
5994     if (jj_3R_177()) {
5995     jj_scanpos = xsp;
5996     if (jj_3R_178()) return true;
5997     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5998     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5999     return false;
6000   }
6001
6002   static final private boolean jj_3R_177() {
6003     Token xsp;
6004     xsp = jj_scanpos;
6005     if (jj_3R_186()) jj_scanpos = xsp;
6006     else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6007     if (jj_3R_187()) return true;
6008     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6009     return false;
6010   }
6011
6012   static final private boolean jj_3R_94() {
6013     if (jj_scan_token(ORASSIGN)) return true;
6014     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6015     return false;
6016   }
6017
6018   static final private boolean jj_3R_93() {
6019     if (jj_scan_token(XORASSIGN)) return true;
6020     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6021     return false;
6022   }
6023
6024   static final private boolean jj_3R_92() {
6025     if (jj_scan_token(ANDASSIGN)) return true;
6026     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6027     return false;
6028   }
6029
6030   static final private boolean jj_3R_91() {
6031     if (jj_scan_token(RSIGNEDSHIFTASSIGN)) return true;
6032     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6033     return false;
6034   }
6035
6036   static final private boolean jj_3R_90() {
6037     if (jj_scan_token(LSHIFTASSIGN)) return true;
6038     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6039     return false;
6040   }
6041
6042   static final private boolean jj_3R_89() {
6043     if (jj_scan_token(MINUSASSIGN)) return true;
6044     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6045     return false;
6046   }
6047
6048   static final private boolean jj_3R_88() {
6049     if (jj_scan_token(PLUSASSIGN)) return true;
6050     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6051     return false;
6052   }
6053
6054   static final private boolean jj_3R_87() {
6055     if (jj_scan_token(REMASSIGN)) return true;
6056     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6057     return false;
6058   }
6059
6060   static final private boolean jj_3R_86() {
6061     if (jj_scan_token(SLASHASSIGN)) return true;
6062     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6063     return false;
6064   }
6065
6066   static final private boolean jj_3R_85() {
6067     if (jj_scan_token(STARASSIGN)) return true;
6068     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6069     return false;
6070   }
6071
6072   static final private boolean jj_3R_84() {
6073     if (jj_scan_token(ASSIGN)) return true;
6074     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6075     return false;
6076   }
6077
6078   static final private boolean jj_3R_80() {
6079     Token xsp;
6080     xsp = jj_scanpos;
6081     if (jj_3R_84()) {
6082     jj_scanpos = xsp;
6083     if (jj_3R_85()) {
6084     jj_scanpos = xsp;
6085     if (jj_3R_86()) {
6086     jj_scanpos = xsp;
6087     if (jj_3R_87()) {
6088     jj_scanpos = xsp;
6089     if (jj_3R_88()) {
6090     jj_scanpos = xsp;
6091     if (jj_3R_89()) {
6092     jj_scanpos = xsp;
6093     if (jj_3R_90()) {
6094     jj_scanpos = xsp;
6095     if (jj_3R_91()) {
6096     jj_scanpos = xsp;
6097     if (jj_3R_92()) {
6098     jj_scanpos = xsp;
6099     if (jj_3R_93()) {
6100     jj_scanpos = xsp;
6101     if (jj_3R_94()) {
6102     jj_scanpos = xsp;
6103     if (jj_3R_95()) {
6104     jj_scanpos = xsp;
6105     if (jj_3R_96()) return true;
6106     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6107     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6108     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6109     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6110     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6111     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6112     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6113     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6114     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6115     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6116     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6117     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6118     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6119     return false;
6120   }
6121
6122   static final private boolean jj_3R_197() {
6123     if (jj_scan_token(MINUS_MINUS)) return true;
6124     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6125     return false;
6126   }
6127
6128   static final private boolean jj_3R_196() {
6129     if (jj_scan_token(PLUS_PLUS)) return true;
6130     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6131     return false;
6132   }
6133
6134   static final private boolean jj_3R_191() {
6135     Token xsp;
6136     xsp = jj_scanpos;
6137     if (jj_3R_196()) {
6138     jj_scanpos = xsp;
6139     if (jj_3R_197()) return true;
6140     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6141     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6142     return false;
6143   }
6144
6145   static final private boolean jj_3R_175() {
6146     if (jj_3R_173()) return true;
6147     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6148     Token xsp;
6149     xsp = jj_scanpos;
6150     if (jj_3R_191()) jj_scanpos = xsp;
6151     else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6152     return false;
6153   }
6154
6155   static final private boolean jj_3R_99() {
6156     if (jj_3R_105()) return true;
6157     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6158     return false;
6159   }
6160
6161   static final private boolean jj_3R_98() {
6162     if (jj_3R_104()) return true;
6163     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6164     return false;
6165   }
6166
6167   static final private boolean jj_3R_82() {
6168     Token xsp;
6169     xsp = jj_scanpos;
6170     if (jj_3R_98()) {
6171     jj_scanpos = xsp;
6172     if (jj_3R_99()) return true;
6173     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6174     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6175     return false;
6176   }
6177
6178   static final private boolean jj_3R_190() {
6179     if (jj_scan_token(ARRAY)) return true;
6180     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6181     return false;
6182   }
6183
6184   static final private boolean jj_3R_189() {
6185     if (jj_3R_50()) return true;
6186     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6187     return false;
6188   }
6189
6190   static final private boolean jj_3R_78() {
6191     if (jj_3R_82()) return true;
6192     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6193     return false;
6194   }
6195
6196   static final private boolean jj_3R_43() {
6197     if (jj_scan_token(ARRAY)) return true;
6198     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6199     return false;
6200   }
6201
6202   static final private boolean jj_3R_77() {
6203     if (jj_scan_token(BANG)) return true;
6204     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6205     if (jj_3R_74()) return true;
6206     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6207     return false;
6208   }
6209
6210   static final private boolean jj_3R_74() {
6211     Token xsp;
6212     xsp = jj_scanpos;
6213     if (jj_3R_77()) {
6214     jj_scanpos = xsp;
6215     if (jj_3R_78()) return true;
6216     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6217     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6218     return false;
6219   }
6220
6221   static final private boolean jj_3R_174() {
6222     if (jj_scan_token(LPAREN)) return true;
6223     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6224     Token xsp;
6225     xsp = jj_scanpos;
6226     if (jj_3R_189()) {
6227     jj_scanpos = xsp;
6228     if (jj_3R_190()) return true;
6229     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6230     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6231     if (jj_scan_token(RPAREN)) return true;
6232     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6233     if (jj_3R_144()) return true;
6234     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6235     return false;
6236   }
6237
6238   static final private boolean jj_3R_42() {
6239     if (jj_3R_50()) return true;
6240     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6241     return false;
6242   }
6243
6244   static final private boolean jj_3R_58() {
6245     if (jj_3R_74()) return true;
6246     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6247     return false;
6248   }
6249
6250   static final private boolean jj_3_3() {
6251     if (jj_scan_token(LPAREN)) return true;
6252     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6253     Token xsp;
6254     xsp = jj_scanpos;
6255     if (jj_3R_42()) {
6256     jj_scanpos = xsp;
6257     if (jj_3R_43()) return true;
6258     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6259     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6260     if (jj_scan_token(RPAREN)) return true;
6261     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6262     return false;
6263   }
6264
6265   static final private boolean jj_3R_172() {
6266     if (jj_scan_token(LPAREN)) return true;
6267     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6268     if (jj_3R_49()) return true;
6269     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6270     if (jj_scan_token(RPAREN)) return true;
6271     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6272     return false;
6273   }
6274
6275   static final private boolean jj_3R_171() {
6276     if (jj_3R_176()) return true;
6277     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6278     return false;
6279   }
6280
6281   static final private boolean jj_3R_170() {
6282     if (jj_3R_175()) return true;
6283     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6284     return false;
6285   }
6286
6287   static final private boolean jj_3R_166() {
6288     Token xsp;
6289     xsp = jj_scanpos;
6290     if (jj_3R_169()) {
6291     jj_scanpos = xsp;
6292     if (jj_3R_170()) {
6293     jj_scanpos = xsp;
6294     if (jj_3R_171()) {
6295     jj_scanpos = xsp;
6296     if (jj_3R_172()) return true;
6297     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6298     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6299     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6300     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6301     return false;
6302   }
6303
6304   static final private boolean jj_3R_169() {
6305     if (jj_3R_174()) return true;
6306     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6307     return false;
6308   }
6309
6310   static final private boolean jj_3R_44() {
6311     if (jj_3R_49()) return true;
6312     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6313     if (jj_scan_token(SEMICOLON)) return true;
6314     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6315     return false;
6316   }
6317
6318   static final private boolean jj_3R_168() {
6319     if (jj_scan_token(MINUS_MINUS)) return true;
6320     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6321     return false;
6322   }
6323
6324   static final private boolean jj_3R_167() {
6325     if (jj_scan_token(PLUS_PLUS)) return true;
6326     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6327     return false;
6328   }
6329
6330   static final private boolean jj_3R_75() {
6331     if (jj_3R_80()) return true;
6332     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6333     if (jj_3R_49()) return true;
6334     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6335     return false;
6336   }
6337
6338   static final private boolean jj_3R_165() {
6339     Token xsp;
6340     xsp = jj_scanpos;
6341     if (jj_3R_167()) {
6342     jj_scanpos = xsp;
6343     if (jj_3R_168()) return true;
6344     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6345     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6346     if (jj_3R_173()) return true;
6347     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6348     return false;
6349   }
6350
6351   static final private boolean jj_3R_49() {
6352     Token xsp;
6353     xsp = jj_scanpos;
6354     if (jj_3R_57()) {
6355     jj_scanpos = xsp;
6356     if (jj_3R_58()) return true;
6357     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6358     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6359     return false;
6360   }
6361
6362   static final private boolean jj_3R_57() {
6363     if (jj_3R_73()) return true;
6364     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6365     Token xsp;
6366     xsp = jj_scanpos;
6367     if (jj_3R_75()) jj_scanpos = xsp;
6368     else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6369     return false;
6370   }
6371
6372   static final private boolean jj_3R_67() {
6373     if (jj_scan_token(OBJECT)) return true;
6374     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6375     return false;
6376   }
6377
6378   static final private boolean jj_3R_161() {
6379     if (jj_3R_166()) return true;
6380     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6381     return false;
6382   }
6383
6384   static final private boolean jj_3R_66() {
6385     if (jj_scan_token(INTEGER)) return true;
6386     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6387     return false;
6388   }
6389
6390   static final private boolean jj_3R_65() {
6391     if (jj_scan_token(INT)) return true;
6392     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6393     return false;
6394   }
6395
6396   static final private boolean jj_3R_64() {
6397     if (jj_scan_token(FLOAT)) return true;
6398     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6399     return false;
6400   }
6401
6402   static final private boolean jj_3R_160() {
6403     if (jj_3R_165()) return true;
6404     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6405     return false;
6406   }
6407
6408   static final private boolean jj_3R_63() {
6409     if (jj_scan_token(DOUBLE)) return true;
6410     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6411     return false;
6412   }
6413
6414   static final private boolean jj_3R_62() {
6415     if (jj_scan_token(REAL)) return true;
6416     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6417     return false;
6418   }
6419
6420   static final private boolean jj_3R_61() {
6421     if (jj_scan_token(BOOLEAN)) return true;
6422     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6423     return false;
6424   }
6425
6426   static final private boolean jj_3R_60() {
6427     if (jj_scan_token(BOOL)) return true;
6428     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6429     return false;
6430   }
6431
6432   static final private boolean jj_3R_159() {
6433     if (jj_scan_token(MINUS)) return true;
6434     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6435     if (jj_3R_148()) return true;
6436     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6437     return false;
6438   }
6439
6440   static final private boolean jj_3R_50() {
6441     Token xsp;
6442     xsp = jj_scanpos;
6443     if (jj_3R_59()) {
6444     jj_scanpos = xsp;
6445     if (jj_3R_60()) {
6446     jj_scanpos = xsp;
6447     if (jj_3R_61()) {
6448     jj_scanpos = xsp;
6449     if (jj_3R_62()) {
6450     jj_scanpos = xsp;
6451     if (jj_3R_63()) {
6452     jj_scanpos = xsp;
6453     if (jj_3R_64()) {
6454     jj_scanpos = xsp;
6455     if (jj_3R_65()) {
6456     jj_scanpos = xsp;
6457     if (jj_3R_66()) {
6458     jj_scanpos = xsp;
6459     if (jj_3R_67()) return true;
6460     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6461     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6462     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6463     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6464     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6465     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6466     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6467     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6468     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6469     return false;
6470   }
6471
6472   static final private boolean jj_3R_59() {
6473     if (jj_scan_token(STRING)) return true;
6474     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6475     return false;
6476   }
6477
6478   static final private boolean jj_3R_156() {
6479     Token xsp;
6480     xsp = jj_scanpos;
6481     if (jj_3R_158()) {
6482     jj_scanpos = xsp;
6483     if (jj_3R_159()) {
6484     jj_scanpos = xsp;
6485     if (jj_3R_160()) {
6486     jj_scanpos = xsp;
6487     if (jj_3R_161()) return true;
6488     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6489     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6490     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6491     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6492     return false;
6493   }
6494
6495   static final private boolean jj_3R_158() {
6496     if (jj_scan_token(PLUS)) return true;
6497     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6498     if (jj_3R_148()) return true;
6499     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6500     return false;
6501   }
6502
6503   static final private boolean jj_3_4() {
6504     if (jj_3R_44()) return true;
6505     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6506     return false;
6507   }
6508
6509   static final private boolean jj_3R_164() {
6510     if (jj_3R_156()) return true;
6511     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6512     return false;
6513   }
6514
6515   static final private boolean jj_3R_163() {
6516     if (jj_scan_token(BANG)) return true;
6517     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6518     if (jj_3R_157()) return true;
6519     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6520     return false;
6521   }
6522
6523   static final private boolean jj_3R_157() {
6524     Token xsp;
6525     xsp = jj_scanpos;
6526     if (jj_3R_162()) {
6527     jj_scanpos = xsp;
6528     if (jj_3R_163()) {
6529     jj_scanpos = xsp;
6530     if (jj_3R_164()) return true;
6531     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6532     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6533     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6534     return false;
6535   }
6536
6537   static final private boolean jj_3R_162() {
6538     if (jj_scan_token(AT)) return true;
6539     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6540     if (jj_3R_157()) return true;
6541     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6542     return false;
6543   }
6544
6545   static final private boolean jj_3R_155() {
6546     if (jj_3R_156()) return true;
6547     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6548     return false;
6549   }
6550
6551   static final private boolean jj_3R_216() {
6552     if (jj_scan_token(COMMA)) return true;
6553     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6554     if (jj_3R_49()) return true;
6555     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6556     return false;
6557   }
6558
6559   static final private boolean jj_3R_154() {
6560     if (jj_scan_token(BANG)) return true;
6561     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6562     if (jj_3R_157()) return true;
6563     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6564     return false;
6565   }
6566
6567   static final private boolean jj_3R_215() {
6568     if (jj_3R_49()) return true;
6569     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6570     Token xsp;
6571     while (true) {
6572       xsp = jj_scanpos;
6573       if (jj_3R_216()) { jj_scanpos = xsp; break; }
6574       if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6575     }
6576     return false;
6577   }
6578
6579   static final private boolean jj_3R_153() {
6580     if (jj_scan_token(TILDE)) return true;
6581     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6582     if (jj_3R_148()) return true;
6583     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6584     return false;
6585   }
6586
6587   static final private boolean jj_3R_148() {
6588     Token xsp;
6589     xsp = jj_scanpos;
6590     if (jj_3R_152()) {
6591     jj_scanpos = xsp;
6592     if (jj_3R_153()) {
6593     jj_scanpos = xsp;
6594     if (jj_3R_154()) {
6595     jj_scanpos = xsp;
6596     if (jj_3R_155()) return true;
6597     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6598     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6599     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6600     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6601     return false;
6602   }
6603
6604   static final private boolean jj_3R_152() {
6605     if (jj_scan_token(AT)) return true;
6606     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6607     if (jj_3R_148()) return true;
6608     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6609     return false;
6610   }
6611
6612   static final private boolean jj_3R_213() {
6613     if (jj_3R_215()) return true;
6614     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6615     return false;
6616   }
6617
6618   static final private boolean jj_3R_144() {
6619     if (jj_3R_148()) return true;
6620     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6621     return false;
6622   }
6623
6624   static final private boolean jj_3R_151() {
6625     if (jj_scan_token(REMAINDER)) return true;
6626     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6627     return false;
6628   }
6629
6630   static final private boolean jj_3R_150() {
6631     if (jj_scan_token(SLASH)) return true;
6632     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6633     return false;
6634   }
6635
6636   static final private boolean jj_3R_149() {
6637     if (jj_scan_token(STAR)) return true;
6638     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6639     return false;
6640   }
6641
6642   static final private boolean jj_3R_207() {
6643     if (jj_scan_token(LPAREN)) return true;
6644     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6645     Token xsp;
6646     xsp = jj_scanpos;
6647     if (jj_3R_213()) jj_scanpos = xsp;
6648     else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6649     if (jj_scan_token(RPAREN)) return true;
6650     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6651     return false;
6652   }
6653
6654   static final private boolean jj_3R_145() {
6655     Token xsp;
6656     xsp = jj_scanpos;
6657     if (jj_3R_149()) {
6658     jj_scanpos = xsp;
6659     if (jj_3R_150()) {
6660     jj_scanpos = xsp;
6661     if (jj_3R_151()) return true;
6662     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6663     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6664     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6665     if (jj_3R_144()) return true;
6666     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6667     return false;
6668   }
6669
6670   static final private boolean jj_3R_139() {
6671     if (jj_3R_144()) return true;
6672     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6673     Token xsp;
6674     while (true) {
6675       xsp = jj_scanpos;
6676       if (jj_3R_145()) { jj_scanpos = xsp; break; }
6677       if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6678     }
6679     return false;
6680   }
6681
6682   static final private boolean jj_3R_212() {
6683     if (jj_scan_token(LBRACE1)) return true;
6684     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6685     if (jj_scan_token(ID)) return true;
6686     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6687     if (jj_scan_token(RBRACE1)) return true;
6688     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6689     return false;
6690   }
6691
6692   static final private boolean jj_3R_147() {
6693     if (jj_scan_token(MINUS)) return true;
6694     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6695     return false;
6696   }
6697
6698   static final private boolean jj_3R_211() {
6699     if (jj_scan_token(IDENTIFIER)) return true;
6700     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6701     return false;
6702   }
6703
6704   static final private boolean jj_3R_146() {
6705     if (jj_scan_token(PLUS)) return true;
6706     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6707     return false;
6708   }
6709
6710   static final private boolean jj_3R_140() {
6711     Token xsp;
6712     xsp = jj_scanpos;
6713     if (jj_3R_146()) {
6714     jj_scanpos = xsp;
6715     if (jj_3R_147()) return true;
6716     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6717     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6718     if (jj_3R_139()) return true;
6719     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6720     return false;
6721   }
6722
6723   static final private boolean jj_3R_199() {
6724     if (jj_scan_token(DOLLARS)) return true;
6725     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6726     Token xsp;
6727     xsp = jj_scanpos;
6728     if (jj_3R_211()) {
6729     jj_scanpos = xsp;
6730     if (jj_3R_212()) return true;
6731     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6732     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6733     return false;
6734   }
6735
6736   static final private boolean jj_3R_133() {
6737     if (jj_3R_139()) return true;
6738     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6739     Token xsp;
6740     while (true) {
6741       xsp = jj_scanpos;
6742       if (jj_3R_140()) { jj_scanpos = xsp; break; }
6743       if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6744     }
6745     return false;
6746   }
6747
6748   static final private boolean jj_3R_192() {
6749     if (jj_scan_token(DOUBLEQUOTE)) return true;
6750     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6751     Token xsp;
6752     while (true) {
6753       xsp = jj_scanpos;
6754       if (jj_3R_199()) { jj_scanpos = xsp; break; }
6755       if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6756     }
6757     if (jj_scan_token(DOUBLEQUOTE2)) return true;
6758     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6759     return false;
6760   }
6761
6762   static final private boolean jj_3R_113() {
6763     if (jj_scan_token(ASSIGN)) return true;
6764     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6765     if (jj_3R_49()) return true;
6766     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6767     return false;
6768   }
6769
6770   static final private boolean jj_3R_143() {
6771     if (jj_scan_token(RUNSIGNEDSHIFT)) return true;
6772     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6773     return false;
6774   }
6775
6776   static final private boolean jj_3R_142() {
6777     if (jj_scan_token(RSIGNEDSHIFT)) return true;
6778     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6779     return false;
6780   }
6781
6782   static final private boolean jj_3R_141() {
6783     if (jj_scan_token(LSHIFT)) return true;
6784     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6785     return false;
6786   }
6787
6788   static final private boolean jj_3R_185() {
6789     if (jj_3R_192()) return true;
6790     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6791     return false;
6792   }
6793
6794   static final private boolean jj_3R_184() {
6795     if (jj_scan_token(NULL)) return true;
6796     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6797     return false;
6798   }
6799
6800   static final private boolean jj_3R_134() {
6801     Token xsp;
6802     xsp = jj_scanpos;
6803     if (jj_3R_141()) {
6804     jj_scanpos = xsp;
6805     if (jj_3R_142()) {
6806     jj_scanpos = xsp;
6807     if (jj_3R_143()) return true;
6808     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6809     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6810     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6811     if (jj_3R_133()) return true;
6812     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6813     return false;
6814   }
6815
6816   static final private boolean jj_3R_183() {
6817     if (jj_scan_token(FALSE)) return true;
6818     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6819     return false;
6820   }
6821
6822   static final private boolean jj_3R_182() {
6823     if (jj_scan_token(TRUE)) return true;
6824     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6825     return false;
6826   }
6827
6828   static final private boolean jj_3R_123() {
6829     if (jj_3R_133()) return true;
6830     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6831     Token xsp;
6832     while (true) {
6833       xsp = jj_scanpos;
6834       if (jj_3R_134()) { jj_scanpos = xsp; break; }
6835       if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6836     }
6837     return false;
6838   }
6839
6840   static final private boolean jj_3R_181() {
6841     if (jj_scan_token(STRING_LITERAL)) return true;
6842     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6843     return false;
6844   }
6845
6846   static final private boolean jj_3R_180() {
6847     if (jj_scan_token(FLOATING_POINT_LITERAL)) return true;
6848     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6849     return false;
6850   }
6851
6852   static final private boolean jj_3R_117() {
6853     if (jj_3R_116()) return true;
6854     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6855     return false;
6856   }
6857
6858   static final private boolean jj_3R_179() {
6859     if (jj_scan_token(INTEGER_LITERAL)) return true;
6860     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6861     return false;
6862   }
6863
6864   static final private boolean jj_3R_176() {
6865     Token xsp;
6866     xsp = jj_scanpos;
6867     if (jj_3R_179()) {
6868     jj_scanpos = xsp;
6869     if (jj_3R_180()) {
6870     jj_scanpos = xsp;
6871     if (jj_3R_181()) {
6872     jj_scanpos = xsp;
6873     if (jj_3R_182()) {
6874     jj_scanpos = xsp;
6875     if (jj_3R_183()) {
6876     jj_scanpos = xsp;
6877     if (jj_3R_184()) {
6878     jj_scanpos = xsp;
6879     if (jj_3R_185()) return true;
6880     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     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6887     return false;
6888   }
6889
6890   static final private boolean jj_3R_138() {
6891     if (jj_scan_token(GE)) return true;
6892     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6893     return false;
6894   }
6895
6896   static final private boolean jj_3R_137() {
6897     if (jj_scan_token(LE)) return true;
6898     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6899     return false;
6900   }
6901
6902   static final private boolean jj_3R_136() {
6903     if (jj_scan_token(GT)) return true;
6904     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6905     return false;
6906   }
6907
6908   static final private boolean jj_3R_112() {
6909     if (jj_scan_token(COMMA)) return true;
6910     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6911     Token xsp;
6912     xsp = jj_scanpos;
6913     if (jj_3R_117()) jj_scanpos = xsp;
6914     else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6915     return false;
6916   }
6917
6918   static final private boolean jj_3R_135() {
6919     if (jj_scan_token(LT)) return true;
6920     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6921     return false;
6922   }
6923
6924   static final private boolean jj_3R_124() {
6925     Token xsp;
6926     xsp = jj_scanpos;
6927     if (jj_3R_135()) {
6928     jj_scanpos = xsp;
6929     if (jj_3R_136()) {
6930     jj_scanpos = xsp;
6931     if (jj_3R_137()) {
6932     jj_scanpos = xsp;
6933     if (jj_3R_138()) return true;
6934     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6935     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6936     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6937     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6938     if (jj_3R_123()) return true;
6939     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6940     return false;
6941   }
6942
6943   static final private boolean jj_3R_120() {
6944     if (jj_3R_123()) return true;
6945     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6946     Token xsp;
6947     while (true) {
6948       xsp = jj_scanpos;
6949       if (jj_3R_124()) { jj_scanpos = xsp; break; }
6950       if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6951     }
6952     return false;
6953   }
6954
6955   static final private boolean jj_3R_111() {
6956     if (jj_3R_116()) return true;
6957     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6958     return false;
6959   }
6960
6961   static final private boolean jj_3R_72() {
6962     if (jj_3R_50()) return true;
6963     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6964     return false;
6965   }
6966
6967   static final private boolean jj_3R_71() {
6968     if (jj_3R_49()) return true;
6969     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6970     return false;
6971   }
6972
6973   static final private boolean jj_3R_56() {
6974     Token xsp;
6975     xsp = jj_scanpos;
6976     if (jj_3R_71()) {
6977     jj_scanpos = xsp;
6978     if (jj_3R_72()) return true;
6979     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6980     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6981     return false;
6982   }
6983
6984   static final private boolean jj_3R_48() {
6985     if (jj_scan_token(LBRACE)) return true;
6986     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6987     Token xsp;
6988     xsp = jj_scanpos;
6989     if (jj_3R_56()) jj_scanpos = xsp;
6990     else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6991     if (jj_scan_token(RBRACE)) return true;
6992     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6993     return false;
6994   }
6995
6996   static final private boolean jj_3R_104() {
6997     if (jj_scan_token(LIST)) return true;
6998     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6999     if (jj_scan_token(LPAREN)) return true;
7000     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7001     Token xsp;
7002     xsp = jj_scanpos;
7003     if (jj_3R_111()) jj_scanpos = xsp;
7004     else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7005     while (true) {
7006       xsp = jj_scanpos;
7007       if (jj_3R_112()) { jj_scanpos = xsp; break; }
7008       if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7009     }
7010     if (jj_scan_token(RPAREN)) return true;
7011     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7012     xsp = jj_scanpos;
7013     if (jj_3R_113()) jj_scanpos = xsp;
7014     else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7015     return false;
7016   }
7017
7018   static final private boolean jj_3R_206() {
7019     if (jj_scan_token(COMMA)) return true;
7020     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7021     return false;
7022   }
7023
7024   static final private boolean jj_3R_70() {
7025     if (jj_3R_50()) return true;
7026     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7027     return false;
7028   }
7029
7030   static final private boolean jj_3_2() {
7031     if (jj_scan_token(COMMA)) return true;
7032     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7033     if (jj_3R_41()) return true;
7034     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7035     return false;
7036   }
7037
7038   static final private boolean jj_3R_55() {
7039     Token xsp;
7040     xsp = jj_scanpos;
7041     if (jj_3R_69()) {
7042     jj_scanpos = xsp;
7043     if (jj_3R_70()) return true;
7044     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7045     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7046     return false;
7047   }
7048
7049   static final private boolean jj_3R_69() {
7050     if (jj_3R_49()) return true;
7051     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7052     return false;
7053   }
7054
7055   static final private boolean jj_3R_205() {
7056     if (jj_3R_41()) return true;
7057     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7058     Token xsp;
7059     while (true) {
7060       xsp = jj_scanpos;
7061       if (jj_3_2()) { jj_scanpos = xsp; break; }
7062       if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7063     }
7064     return false;
7065   }
7066
7067   static final private boolean jj_3R_47() {
7068     if (jj_scan_token(LBRACKET)) return true;
7069     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7070     Token xsp;
7071     xsp = jj_scanpos;
7072     if (jj_3R_55()) jj_scanpos = xsp;
7073     else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7074     if (jj_scan_token(RBRACKET)) return true;
7075     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7076     return false;
7077   }
7078
7079   static final private boolean jj_3R_129() {
7080     if (jj_scan_token(TRIPLEEQUAL)) return true;
7081     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7082     return false;
7083   }
7084
7085   static final private boolean jj_3R_128() {
7086     if (jj_scan_token(BANGDOUBLEEQUAL)) return true;
7087     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7088     return false;
7089   }
7090
7091   static final private boolean jj_3R_127() {
7092     if (jj_scan_token(NOT_EQUAL)) return true;
7093     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7094     return false;
7095   }
7096
7097   static final private boolean jj_3R_126() {
7098     if (jj_scan_token(DIF)) return true;
7099     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7100     return false;
7101   }
7102
7103   static final private boolean jj_3R_105() {
7104     if (jj_scan_token(PRINT)) return true;
7105     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7106     if (jj_3R_49()) return true;
7107     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7108     return false;
7109   }
7110
7111   static final private boolean jj_3R_198() {
7112     if (jj_scan_token(LPAREN)) return true;
7113     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7114     Token xsp;
7115     xsp = jj_scanpos;
7116     if (jj_3R_205()) jj_scanpos = xsp;
7117     else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7118     xsp = jj_scanpos;
7119     if (jj_3R_206()) jj_scanpos = xsp;
7120     else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7121     if (jj_scan_token(RPAREN)) return true;
7122     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7123     return false;
7124   }
7125
7126   static final private boolean jj_3R_125() {
7127     if (jj_scan_token(EQUAL_EQUAL)) return true;
7128     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7129     return false;
7130   }
7131
7132   static final private boolean jj_3R_54() {
7133     if (jj_3R_68()) return true;
7134     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7135     return false;
7136   }
7137
7138   static final private boolean jj_3R_121() {
7139     Token xsp;
7140     xsp = jj_scanpos;
7141     if (jj_3R_125()) {
7142     jj_scanpos = xsp;
7143     if (jj_3R_126()) {
7144     jj_scanpos = xsp;
7145     if (jj_3R_127()) {
7146     jj_scanpos = xsp;
7147     if (jj_3R_128()) {
7148     jj_scanpos = xsp;
7149     if (jj_3R_129()) return true;
7150     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7151     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7152     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7153     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7154     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7155     if (jj_3R_120()) return true;
7156     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7157     return false;
7158   }
7159
7160   static final private boolean jj_3R_53() {
7161     if (jj_scan_token(IDENTIFIER)) return true;
7162     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7163     return false;
7164   }
7165
7166   static final private boolean jj_3R_118() {
7167     if (jj_3R_120()) return true;
7168     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7169     Token xsp;
7170     while (true) {
7171       xsp = jj_scanpos;
7172       if (jj_3R_121()) { jj_scanpos = xsp; break; }
7173       if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7174     }
7175     return false;
7176   }
7177
7178   static final private boolean jj_3R_214() {
7179     if (jj_scan_token(ARRAYASSIGN)) return true;
7180     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7181     if (jj_3R_49()) return true;
7182     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7183     return false;
7184   }
7185
7186   static final private boolean jj_3R_52() {
7187     if (jj_scan_token(LBRACE)) return true;
7188     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7189     if (jj_3R_49()) return true;
7190     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7191     if (jj_scan_token(RBRACE)) return true;
7192     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7193     return false;
7194   }
7195
7196   static final private boolean jj_3R_41() {
7197     if (jj_3R_49()) return true;
7198     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7199     Token xsp;
7200     xsp = jj_scanpos;
7201     if (jj_3R_214()) jj_scanpos = xsp;
7202     else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7203     return false;
7204   }
7205
7206   static final private boolean jj_3R_119() {
7207     if (jj_scan_token(BIT_AND)) return true;
7208     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7209     if (jj_3R_118()) return true;
7210     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7211     return false;
7212   }
7213
7214   static final private boolean jj_3R_46() {
7215     if (jj_scan_token(CLASSACCESS)) return true;
7216     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7217     Token xsp;
7218     xsp = jj_scanpos;
7219     if (jj_3R_52()) {
7220     jj_scanpos = xsp;
7221     if (jj_3R_53()) {
7222     jj_scanpos = xsp;
7223     if (jj_3R_54()) return true;
7224     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7225     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7226     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7227     return false;
7228   }
7229
7230   static final private boolean jj_3R_40() {
7231     Token xsp;
7232     xsp = jj_scanpos;
7233     if (jj_3R_46()) {
7234     jj_scanpos = xsp;
7235     if (jj_3R_47()) {
7236     jj_scanpos = xsp;
7237     if (jj_3R_48()) return true;
7238     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7239     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7240     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7241     return false;
7242   }
7243
7244   static final private boolean jj_3R_114() {
7245     if (jj_3R_118()) return true;
7246     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7247     Token xsp;
7248     while (true) {
7249       xsp = jj_scanpos;
7250       if (jj_3R_119()) { jj_scanpos = xsp; break; }
7251       if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7252     }
7253     return false;
7254   }
7255
7256   static final private boolean jj_3R_115() {
7257     if (jj_scan_token(XOR)) return true;
7258     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7259     if (jj_3R_114()) return true;
7260     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7261     return false;
7262   }
7263
7264   static private boolean jj_initialized_once = false;
7265   static public PHPParserTokenManager token_source;
7266   static SimpleCharStream jj_input_stream;
7267   static public Token token, jj_nt;
7268   static private int jj_ntk;
7269   static private Token jj_scanpos, jj_lastpos;
7270   static private int jj_la;
7271   static public boolean lookingAhead = false;
7272   static private boolean jj_semLA;
7273   static private int jj_gen;
7274   static final private int[] jj_la1 = new int[128];
7275   static private int[] jj_la1_0;
7276   static private int[] jj_la1_1;
7277   static private int[] jj_la1_2;
7278   static private int[] jj_la1_3;
7279   static private int[] jj_la1_4;
7280   static {
7281       jj_la1_0();
7282       jj_la1_1();
7283       jj_la1_2();
7284       jj_la1_3();
7285       jj_la1_4();
7286    }
7287    private static void jj_la1_0() {
7288       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,};
7289    }
7290    private static void jj_la1_1() {
7291       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,};
7292    }
7293    private static void jj_la1_2() {
7294       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,};
7295    }
7296    private static void jj_la1_3() {
7297       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,};
7298    }
7299    private static void jj_la1_4() {
7300       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,};
7301    }
7302   static final private JJCalls[] jj_2_rtns = new JJCalls[5];
7303   static private boolean jj_rescan = false;
7304   static private int jj_gc = 0;
7305
7306   public PHPParser(java.io.InputStream stream) {
7307     if (jj_initialized_once) {
7308       System.out.println("ERROR: Second call to constructor of static parser.  You must");
7309       System.out.println("       either use ReInit() or set the JavaCC option STATIC to false");
7310       System.out.println("       during parser generation.");
7311       throw new Error();
7312     }
7313     jj_initialized_once = true;
7314     jj_input_stream = new SimpleCharStream(stream, 1, 1);
7315     token_source = new PHPParserTokenManager(jj_input_stream);
7316     token = new Token();
7317     jj_ntk = -1;
7318     jj_gen = 0;
7319     for (int i = 0; i < 128; i++) jj_la1[i] = -1;
7320     for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
7321   }
7322
7323   static public void ReInit(java.io.InputStream stream) {
7324     jj_input_stream.ReInit(stream, 1, 1);
7325     token_source.ReInit(jj_input_stream);
7326     token = new Token();
7327     jj_ntk = -1;
7328     jj_gen = 0;
7329     for (int i = 0; i < 128; i++) jj_la1[i] = -1;
7330     for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
7331   }
7332
7333   public PHPParser(java.io.Reader stream) {
7334     if (jj_initialized_once) {
7335       System.out.println("ERROR: Second call to constructor of static parser.  You must");
7336       System.out.println("       either use ReInit() or set the JavaCC option STATIC to false");
7337       System.out.println("       during parser generation.");
7338       throw new Error();
7339     }
7340     jj_initialized_once = true;
7341     jj_input_stream = new SimpleCharStream(stream, 1, 1);
7342     token_source = new PHPParserTokenManager(jj_input_stream);
7343     token = new Token();
7344     jj_ntk = -1;
7345     jj_gen = 0;
7346     for (int i = 0; i < 128; i++) jj_la1[i] = -1;
7347     for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
7348   }
7349
7350   static public void ReInit(java.io.Reader stream) {
7351     jj_input_stream.ReInit(stream, 1, 1);
7352     token_source.ReInit(jj_input_stream);
7353     token = new Token();
7354     jj_ntk = -1;
7355     jj_gen = 0;
7356     for (int i = 0; i < 128; i++) jj_la1[i] = -1;
7357     for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
7358   }
7359
7360   public PHPParser(PHPParserTokenManager tm) {
7361     if (jj_initialized_once) {
7362       System.out.println("ERROR: Second call to constructor of static parser.  You must");
7363       System.out.println("       either use ReInit() or set the JavaCC option STATIC to false");
7364       System.out.println("       during parser generation.");
7365       throw new Error();
7366     }
7367     jj_initialized_once = true;
7368     token_source = tm;
7369     token = new Token();
7370     jj_ntk = -1;
7371     jj_gen = 0;
7372     for (int i = 0; i < 128; i++) jj_la1[i] = -1;
7373     for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
7374   }
7375
7376   public void ReInit(PHPParserTokenManager tm) {
7377     token_source = tm;
7378     token = new Token();
7379     jj_ntk = -1;
7380     jj_gen = 0;
7381     for (int i = 0; i < 128; i++) jj_la1[i] = -1;
7382     for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
7383   }
7384
7385   static final private Token jj_consume_token(int kind) throws ParseException {
7386     Token oldToken;
7387     if ((oldToken = token).next != null) token = token.next;
7388     else token = token.next = token_source.getNextToken();
7389     jj_ntk = -1;
7390     if (token.kind == kind) {
7391       jj_gen++;
7392       if (++jj_gc > 100) {
7393         jj_gc = 0;
7394         for (int i = 0; i < jj_2_rtns.length; i++) {
7395           JJCalls c = jj_2_rtns[i];
7396           while (c != null) {
7397             if (c.gen < jj_gen) c.first = null;
7398             c = c.next;
7399           }
7400         }
7401       }
7402       return token;
7403     }
7404     token = oldToken;
7405     jj_kind = kind;
7406     throw generateParseException();
7407   }
7408
7409   static final private boolean jj_scan_token(int kind) {
7410     if (jj_scanpos == jj_lastpos) {
7411       jj_la--;
7412       if (jj_scanpos.next == null) {
7413         jj_lastpos = jj_scanpos = jj_scanpos.next = token_source.getNextToken();
7414       } else {
7415         jj_lastpos = jj_scanpos = jj_scanpos.next;
7416       }
7417     } else {
7418       jj_scanpos = jj_scanpos.next;
7419     }
7420     if (jj_rescan) {
7421       int i = 0; Token tok = token;
7422       while (tok != null && tok != jj_scanpos) { i++; tok = tok.next; }
7423       if (tok != null) jj_add_error_token(kind, i);
7424     }
7425     return (jj_scanpos.kind != kind);
7426   }
7427
7428   static final public Token getNextToken() {
7429     if (token.next != null) token = token.next;
7430     else token = token.next = token_source.getNextToken();
7431     jj_ntk = -1;
7432     jj_gen++;
7433     return token;
7434   }
7435
7436   static final public Token getToken(int index) {
7437     Token t = lookingAhead ? jj_scanpos : token;
7438     for (int i = 0; i < index; i++) {
7439       if (t.next != null) t = t.next;
7440       else t = t.next = token_source.getNextToken();
7441     }
7442     return t;
7443   }
7444
7445   static final private int jj_ntk() {
7446     if ((jj_nt=token.next) == null)
7447       return (jj_ntk = (token.next=token_source.getNextToken()).kind);
7448     else
7449       return (jj_ntk = jj_nt.kind);
7450   }
7451
7452   static private java.util.Vector jj_expentries = new java.util.Vector();
7453   static private int[] jj_expentry;
7454   static private int jj_kind = -1;
7455   static private int[] jj_lasttokens = new int[100];
7456   static private int jj_endpos;
7457
7458   static private void jj_add_error_token(int kind, int pos) {
7459     if (pos >= 100) return;
7460     if (pos == jj_endpos + 1) {
7461       jj_lasttokens[jj_endpos++] = kind;
7462     } else if (jj_endpos != 0) {
7463       jj_expentry = new int[jj_endpos];
7464       for (int i = 0; i < jj_endpos; i++) {
7465         jj_expentry[i] = jj_lasttokens[i];
7466       }
7467       boolean exists = false;
7468       for (java.util.Enumeration enum = jj_expentries.elements(); enum.hasMoreElements();) {
7469         int[] oldentry = (int[])(enum.nextElement());
7470         if (oldentry.length == jj_expentry.length) {
7471           exists = true;
7472           for (int i = 0; i < jj_expentry.length; i++) {
7473             if (oldentry[i] != jj_expentry[i]) {
7474               exists = false;
7475               break;
7476             }
7477           }
7478           if (exists) break;
7479         }
7480       }
7481       if (!exists) jj_expentries.addElement(jj_expentry);
7482       if (pos != 0) jj_lasttokens[(jj_endpos = pos) - 1] = kind;
7483     }
7484   }
7485
7486   static public ParseException generateParseException() {
7487     jj_expentries.removeAllElements();
7488     boolean[] la1tokens = new boolean[160];
7489     for (int i = 0; i < 160; i++) {
7490       la1tokens[i] = false;
7491     }
7492     if (jj_kind >= 0) {
7493       la1tokens[jj_kind] = true;
7494       jj_kind = -1;
7495     }
7496     for (int i = 0; i < 128; i++) {
7497       if (jj_la1[i] == jj_gen) {
7498         for (int j = 0; j < 32; j++) {
7499           if ((jj_la1_0[i] & (1<<j)) != 0) {
7500             la1tokens[j] = true;
7501           }
7502           if ((jj_la1_1[i] & (1<<j)) != 0) {
7503             la1tokens[32+j] = true;
7504           }
7505           if ((jj_la1_2[i] & (1<<j)) != 0) {
7506             la1tokens[64+j] = true;
7507           }
7508           if ((jj_la1_3[i] & (1<<j)) != 0) {
7509             la1tokens[96+j] = true;
7510           }
7511           if ((jj_la1_4[i] & (1<<j)) != 0) {
7512             la1tokens[128+j] = true;
7513           }
7514         }
7515       }
7516     }
7517     for (int i = 0; i < 160; i++) {
7518       if (la1tokens[i]) {
7519         jj_expentry = new int[1];
7520         jj_expentry[0] = i;
7521         jj_expentries.addElement(jj_expentry);
7522       }
7523     }
7524     jj_endpos = 0;
7525     jj_rescan_token();
7526     jj_add_error_token(0, 0);
7527     int[][] exptokseq = new int[jj_expentries.size()][];
7528     for (int i = 0; i < jj_expentries.size(); i++) {
7529       exptokseq[i] = (int[])jj_expentries.elementAt(i);
7530     }
7531     return new ParseException(token, exptokseq, tokenImage);
7532   }
7533
7534   static final public void enable_tracing() {
7535   }
7536
7537   static final public void disable_tracing() {
7538   }
7539
7540   static final private void jj_rescan_token() {
7541     jj_rescan = true;
7542     for (int i = 0; i < 5; i++) {
7543       JJCalls p = jj_2_rtns[i];
7544       do {
7545         if (p.gen > jj_gen) {
7546           jj_la = p.arg; jj_lastpos = jj_scanpos = p.first;
7547           switch (i) {
7548             case 0: jj_3_1(); break;
7549             case 1: jj_3_2(); break;
7550             case 2: jj_3_3(); break;
7551             case 3: jj_3_4(); break;
7552             case 4: jj_3_5(); break;
7553           }
7554         }
7555         p = p.next;
7556       } while (p != null);
7557     }
7558     jj_rescan = false;
7559   }
7560
7561   static final private void jj_save(int index, int xla) {
7562     JJCalls p = jj_2_rtns[index];
7563     while (p.gen > jj_gen) {
7564       if (p.next == null) { p = p.next = new JJCalls(); break; }
7565       p = p.next;
7566     }
7567     p.gen = jj_gen + xla - jj_la; p.first = token; p.arg = xla;
7568   }
7569
7570   static final class JJCalls {
7571     int gen;
7572     Token first;
7573     int arg;
7574     JJCalls next;
7575   }
7576
7577 }