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

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