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

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