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

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