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