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

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