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