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