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