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

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