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