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