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;
 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           try {
1679             jj_consume_token(RPAREN);
1680           } catch (ParseException e) {
1681     errorMessage = "')' expected";
1682     errorLevel   = ERROR;
1683     {if (true) throw e;}
1684           }
1685    {if (true) return "("+expr+")";}
1686           break;
1687         default:
1688           jj_la1[53] = jj_gen;
1689           jj_consume_token(-1);
1690           throw new ParseException();
1691         }
1692       }
1693     }
1694     throw new Error("Missing return statement in function");
1695   }
1696
1697   static final public String CastExpression() throws ParseException {
1698 final String type, expr;
1699     jj_consume_token(LPAREN);
1700     type = Type();
1701     jj_consume_token(RPAREN);
1702     expr = UnaryExpression();
1703    {if (true) return "(" + type + ")" + expr;}
1704     throw new Error("Missing return statement in function");
1705   }
1706
1707   static final public String PostfixExpression() throws ParseException {
1708   final String expr;
1709   Token operator = null;
1710     expr = PrimaryExpression();
1711     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1712     case INCR:
1713     case DECR:
1714       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1715       case INCR:
1716         operator = jj_consume_token(INCR);
1717         break;
1718       case DECR:
1719         operator = jj_consume_token(DECR);
1720         break;
1721       default:
1722         jj_la1[54] = jj_gen;
1723         jj_consume_token(-1);
1724         throw new ParseException();
1725       }
1726       break;
1727     default:
1728       jj_la1[55] = jj_gen;
1729       ;
1730     }
1731     if (operator == null) {
1732       {if (true) return expr;}
1733     }
1734     {if (true) return expr + operator.image;}
1735     throw new Error("Missing return statement in function");
1736   }
1737
1738   static final public String PrimaryExpression() throws ParseException {
1739   final Token identifier;
1740   String expr;
1741   final StringBuffer buff = new StringBuffer();
1742     if (jj_2_4(2)) {
1743       identifier = jj_consume_token(IDENTIFIER);
1744       jj_consume_token(STATICCLASSACCESS);
1745       expr = ClassIdentifier();
1746    buff.append(identifier.image).append("::").append(expr);
1747       label_20:
1748       while (true) {
1749         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1750         case CLASSACCESS:
1751         case LPAREN:
1752         case LBRACKET:
1753           ;
1754           break;
1755         default:
1756           jj_la1[56] = jj_gen;
1757           break label_20;
1758         }
1759         expr = PrimarySuffix();
1760    buff.append(expr);
1761       }
1762    {if (true) return buff.toString();}
1763     } else {
1764       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1765       case NEW:
1766       case IDENTIFIER:
1767       case DOLLAR:
1768       case DOLLAR_ID:
1769         expr = PrimaryPrefix();
1770                            buff.append(expr);
1771         label_21:
1772         while (true) {
1773           switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1774           case CLASSACCESS:
1775           case LPAREN:
1776           case LBRACKET:
1777             ;
1778             break;
1779           default:
1780             jj_la1[57] = jj_gen;
1781             break label_21;
1782           }
1783           expr = PrimarySuffix();
1784                              buff.append(expr);
1785         }
1786    {if (true) return buff.toString();}
1787         break;
1788       case ARRAY:
1789         expr = ArrayDeclarator();
1790    {if (true) return "array" + expr;}
1791         break;
1792       default:
1793         jj_la1[58] = jj_gen;
1794         jj_consume_token(-1);
1795         throw new ParseException();
1796       }
1797     }
1798     throw new Error("Missing return statement in function");
1799   }
1800
1801   static final public String ArrayDeclarator() throws ParseException {
1802   final String expr;
1803     jj_consume_token(ARRAY);
1804     expr = ArrayInitializer();
1805    {if (true) return "array" + expr;}
1806     throw new Error("Missing return statement in function");
1807   }
1808
1809   static final public String PrimaryPrefix() throws ParseException {
1810   final String expr;
1811   final Token token;
1812     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1813     case IDENTIFIER:
1814       token = jj_consume_token(IDENTIFIER);
1815    {if (true) return token.image;}
1816       break;
1817     case NEW:
1818       jj_consume_token(NEW);
1819       expr = ClassIdentifier();
1820     {if (true) return "new " + expr;}
1821       break;
1822     case DOLLAR:
1823     case DOLLAR_ID:
1824       expr = VariableDeclaratorId();
1825    {if (true) return expr;}
1826       break;
1827     default:
1828       jj_la1[59] = jj_gen;
1829       jj_consume_token(-1);
1830       throw new ParseException();
1831     }
1832     throw new Error("Missing return statement in function");
1833   }
1834
1835   static final public String ClassIdentifier() throws ParseException {
1836   final String expr;
1837   final Token token;
1838     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1839     case IDENTIFIER:
1840       token = jj_consume_token(IDENTIFIER);
1841    {if (true) return token.image;}
1842       break;
1843     case DOLLAR:
1844     case DOLLAR_ID:
1845       expr = VariableDeclaratorId();
1846    {if (true) return expr;}
1847       break;
1848     default:
1849       jj_la1[60] = jj_gen;
1850       jj_consume_token(-1);
1851       throw new ParseException();
1852     }
1853     throw new Error("Missing return statement in function");
1854   }
1855
1856   static final public String PrimarySuffix() throws ParseException {
1857   final String expr;
1858     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1859     case LPAREN:
1860       expr = Arguments();
1861    {if (true) return expr;}
1862       break;
1863     case CLASSACCESS:
1864     case LBRACKET:
1865       expr = VariableSuffix();
1866    {if (true) return expr;}
1867       break;
1868     default:
1869       jj_la1[61] = jj_gen;
1870       jj_consume_token(-1);
1871       throw new ParseException();
1872     }
1873     throw new Error("Missing return statement in function");
1874   }
1875
1876   static final public String VariableSuffix() throws ParseException {
1877   String expr = null;
1878     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1879     case CLASSACCESS:
1880       jj_consume_token(CLASSACCESS);
1881       expr = VariableName();
1882    {if (true) return "->" + expr;}
1883       break;
1884     case LBRACKET:
1885       jj_consume_token(LBRACKET);
1886       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1887       case ARRAY:
1888       case PRINT:
1889       case LIST:
1890       case NEW:
1891       case NULL:
1892       case TRUE:
1893       case FALSE:
1894       case INTEGER_LITERAL:
1895       case FLOATING_POINT_LITERAL:
1896       case STRING_LITERAL:
1897       case IDENTIFIER:
1898       case LPAREN:
1899       case AT:
1900       case DOLLAR:
1901       case BANG:
1902       case INCR:
1903       case DECR:
1904       case PLUS:
1905       case MINUS:
1906       case BIT_AND:
1907       case DOLLAR_ID:
1908         expr = Expression();
1909         break;
1910       default:
1911         jj_la1[62] = jj_gen;
1912         ;
1913       }
1914       try {
1915         jj_consume_token(RBRACKET);
1916       } catch (ParseException e) {
1917     errorMessage = "']' expected";
1918     errorLevel   = ERROR;
1919     {if (true) throw e;}
1920       }
1921     if(expr == null) {
1922       {if (true) return "[]";}
1923     }
1924     {if (true) return "[" + expr + "]";}
1925       break;
1926     default:
1927       jj_la1[63] = jj_gen;
1928       jj_consume_token(-1);
1929       throw new ParseException();
1930     }
1931     throw new Error("Missing return statement in function");
1932   }
1933
1934   static final public String Literal() throws ParseException {
1935   final String expr;
1936   final Token token;
1937     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1938     case INTEGER_LITERAL:
1939       token = jj_consume_token(INTEGER_LITERAL);
1940    {if (true) return token.image;}
1941       break;
1942     case FLOATING_POINT_LITERAL:
1943       token = jj_consume_token(FLOATING_POINT_LITERAL);
1944    {if (true) return token.image;}
1945       break;
1946     case STRING_LITERAL:
1947       token = jj_consume_token(STRING_LITERAL);
1948    {if (true) return token.image;}
1949       break;
1950     case TRUE:
1951     case FALSE:
1952       expr = BooleanLiteral();
1953    {if (true) return expr;}
1954       break;
1955     case NULL:
1956       expr = NullLiteral();
1957    {if (true) return expr;}
1958       break;
1959     default:
1960       jj_la1[64] = jj_gen;
1961       jj_consume_token(-1);
1962       throw new ParseException();
1963     }
1964     throw new Error("Missing return statement in function");
1965   }
1966
1967   static final public String BooleanLiteral() throws ParseException {
1968     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1969     case TRUE:
1970       jj_consume_token(TRUE);
1971    {if (true) return "true";}
1972       break;
1973     case FALSE:
1974       jj_consume_token(FALSE);
1975    {if (true) return "false";}
1976       break;
1977     default:
1978       jj_la1[65] = jj_gen;
1979       jj_consume_token(-1);
1980       throw new ParseException();
1981     }
1982     throw new Error("Missing return statement in function");
1983   }
1984
1985   static final public String NullLiteral() throws ParseException {
1986     jj_consume_token(NULL);
1987    {if (true) return "null";}
1988     throw new Error("Missing return statement in function");
1989   }
1990
1991   static final public String Arguments() throws ParseException {
1992 String expr = null;
1993     jj_consume_token(LPAREN);
1994     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1995     case ARRAY:
1996     case PRINT:
1997     case LIST:
1998     case NEW:
1999     case NULL:
2000     case TRUE:
2001     case FALSE:
2002     case INTEGER_LITERAL:
2003     case FLOATING_POINT_LITERAL:
2004     case STRING_LITERAL:
2005     case IDENTIFIER:
2006     case LPAREN:
2007     case AT:
2008     case DOLLAR:
2009     case BANG:
2010     case INCR:
2011     case DECR:
2012     case PLUS:
2013     case MINUS:
2014     case BIT_AND:
2015     case DOLLAR_ID:
2016       expr = ArgumentList();
2017       break;
2018     default:
2019       jj_la1[66] = jj_gen;
2020       ;
2021     }
2022     try {
2023       jj_consume_token(RPAREN);
2024     } catch (ParseException e) {
2025     errorMessage = "')' expected to close the argument list";
2026     errorLevel   = ERROR;
2027     {if (true) throw e;}
2028     }
2029   if (expr == null) {
2030     {if (true) return "()";}
2031   }
2032   {if (true) return "(" + expr + ")";}
2033     throw new Error("Missing return statement in function");
2034   }
2035
2036   static final public String ArgumentList() throws ParseException {
2037 String expr;
2038 final StringBuffer buff = new StringBuffer();
2039     expr = Expression();
2040    buff.append(expr);
2041     label_22:
2042     while (true) {
2043       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2044       case COMMA:
2045         ;
2046         break;
2047       default:
2048         jj_la1[67] = jj_gen;
2049         break label_22;
2050       }
2051       jj_consume_token(COMMA);
2052       try {
2053         expr = Expression();
2054       } catch (ParseException e) {
2055         errorMessage = "expression expected after a comma in argument list";
2056         errorLevel   = ERROR;
2057         {if (true) throw e;}
2058       }
2059       buff.append(",").append(expr);
2060     }
2061     {if (true) return buff.toString();}
2062     throw new Error("Missing return statement in function");
2063   }
2064
2065 /*
2066  * Statement syntax follows.
2067  */
2068   static final public void StatementNoBreak() throws ParseException {
2069     if (jj_2_5(2)) {
2070       Expression();
2071       try {
2072         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2073         case SEMICOLON:
2074           jj_consume_token(SEMICOLON);
2075           break;
2076         case PHPEND:
2077           jj_consume_token(PHPEND);
2078           break;
2079         default:
2080           jj_la1[68] = jj_gen;
2081           jj_consume_token(-1);
2082           throw new ParseException();
2083         }
2084       } catch (ParseException e) {
2085     errorMessage = "';' expected";
2086     errorLevel   = ERROR;
2087     {if (true) throw e;}
2088       }
2089     } else if (jj_2_6(2)) {
2090       LabeledStatement();
2091     } else {
2092       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2093       case LBRACE:
2094         Block();
2095         break;
2096       case SEMICOLON:
2097         EmptyStatement();
2098         break;
2099       case ARRAY:
2100       case NEW:
2101       case IDENTIFIER:
2102       case DOLLAR:
2103       case INCR:
2104       case DECR:
2105       case DOLLAR_ID:
2106         StatementExpression();
2107         try {
2108           jj_consume_token(SEMICOLON);
2109         } catch (ParseException e) {
2110     errorMessage = "';' expected after expression";
2111     errorLevel   = ERROR;
2112     {if (true) throw e;}
2113         }
2114         break;
2115       case SWITCH:
2116         SwitchStatement();
2117         break;
2118       case IF:
2119         IfStatement();
2120         break;
2121       case WHILE:
2122         WhileStatement();
2123         break;
2124       case DO:
2125         DoStatement();
2126         break;
2127       case FOR:
2128         ForStatement();
2129         break;
2130       case FOREACH:
2131         ForeachStatement();
2132         break;
2133       case CONTINUE:
2134         ContinueStatement();
2135         break;
2136       case RETURN:
2137         ReturnStatement();
2138         break;
2139       case ECHO:
2140         EchoStatement();
2141         break;
2142       case INCLUDE:
2143       case REQUIRE:
2144       case INCLUDE_ONCE:
2145       case REQUIRE_ONCE:
2146       case AT:
2147         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2148         case AT:
2149           jj_consume_token(AT);
2150           break;
2151         default:
2152           jj_la1[69] = jj_gen;
2153           ;
2154         }
2155         IncludeStatement();
2156         break;
2157       case STATIC:
2158         StaticStatement();
2159         break;
2160       case GLOBAL:
2161         GlobalStatement();
2162         break;
2163       default:
2164         jj_la1[70] = jj_gen;
2165         jj_consume_token(-1);
2166         throw new ParseException();
2167       }
2168     }
2169   }
2170
2171   static final public void Statement() throws ParseException {
2172     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2173     case IF:
2174     case ARRAY:
2175     case PRINT:
2176     case ECHO:
2177     case INCLUDE:
2178     case REQUIRE:
2179     case INCLUDE_ONCE:
2180     case REQUIRE_ONCE:
2181     case GLOBAL:
2182     case STATIC:
2183     case LIST:
2184     case CONTINUE:
2185     case DO:
2186     case FOR:
2187     case NEW:
2188     case NULL:
2189     case RETURN:
2190     case SWITCH:
2191     case TRUE:
2192     case FALSE:
2193     case WHILE:
2194     case FOREACH:
2195     case INTEGER_LITERAL:
2196     case FLOATING_POINT_LITERAL:
2197     case STRING_LITERAL:
2198     case IDENTIFIER:
2199     case LPAREN:
2200     case LBRACE:
2201     case SEMICOLON:
2202     case AT:
2203     case DOLLAR:
2204     case BANG:
2205     case INCR:
2206     case DECR:
2207     case PLUS:
2208     case MINUS:
2209     case BIT_AND:
2210     case DOLLAR_ID:
2211       StatementNoBreak();
2212       break;
2213     case BREAK:
2214       BreakStatement();
2215       break;
2216     default:
2217       jj_la1[71] = jj_gen;
2218       jj_consume_token(-1);
2219       throw new ParseException();
2220     }
2221   }
2222
2223   static final public void IncludeStatement() throws ParseException {
2224   final String expr;
2225   final int pos = jj_input_stream.bufpos;
2226     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2227     case REQUIRE:
2228       jj_consume_token(REQUIRE);
2229       expr = Expression();
2230     if (currentSegment != null) {
2231       currentSegment.add(new PHPReqIncDeclaration(currentSegment, "require",pos,expr));
2232     }
2233       try {
2234         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2235         case SEMICOLON:
2236           jj_consume_token(SEMICOLON);
2237           break;
2238         case 138:
2239           jj_consume_token(138);
2240           break;
2241         default:
2242           jj_la1[72] = jj_gen;
2243           jj_consume_token(-1);
2244           throw new ParseException();
2245         }
2246       } catch (ParseException e) {
2247     errorMessage = "';' expected";
2248     errorLevel   = ERROR;
2249     {if (true) throw e;}
2250       }
2251       break;
2252     case REQUIRE_ONCE:
2253       jj_consume_token(REQUIRE_ONCE);
2254       expr = Expression();
2255     if (currentSegment != null) {
2256       currentSegment.add(new PHPReqIncDeclaration(currentSegment, "require_once",pos,expr));
2257     }
2258       try {
2259         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2260         case SEMICOLON:
2261           jj_consume_token(SEMICOLON);
2262           break;
2263         case 138:
2264           jj_consume_token(138);
2265           break;
2266         default:
2267           jj_la1[73] = jj_gen;
2268           jj_consume_token(-1);
2269           throw new ParseException();
2270         }
2271       } catch (ParseException e) {
2272     errorMessage = "';' expected";
2273     errorLevel   = ERROR;
2274     {if (true) throw e;}
2275       }
2276       break;
2277     case INCLUDE:
2278       jj_consume_token(INCLUDE);
2279       expr = Expression();
2280     if (currentSegment != null) {
2281       currentSegment.add(new PHPReqIncDeclaration(currentSegment, "include",pos,expr));
2282     }
2283       try {
2284         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2285         case SEMICOLON:
2286           jj_consume_token(SEMICOLON);
2287           break;
2288         case 138:
2289           jj_consume_token(138);
2290           break;
2291         default:
2292           jj_la1[74] = jj_gen;
2293           jj_consume_token(-1);
2294           throw new ParseException();
2295         }
2296       } catch (ParseException e) {
2297     errorMessage = "';' expected";
2298     errorLevel   = ERROR;
2299     {if (true) throw e;}
2300       }
2301       break;
2302     case INCLUDE_ONCE:
2303       jj_consume_token(INCLUDE_ONCE);
2304       expr = Expression();
2305     if (currentSegment != null) {
2306       currentSegment.add(new PHPReqIncDeclaration(currentSegment, "include_once",pos,expr));
2307     }
2308       try {
2309         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2310         case SEMICOLON:
2311           jj_consume_token(SEMICOLON);
2312           break;
2313         case 138:
2314           jj_consume_token(138);
2315           break;
2316         default:
2317           jj_la1[75] = jj_gen;
2318           jj_consume_token(-1);
2319           throw new ParseException();
2320         }
2321       } catch (ParseException e) {
2322     errorMessage = "';' expected";
2323     errorLevel   = ERROR;
2324     {if (true) throw e;}
2325       }
2326       break;
2327     default:
2328       jj_la1[76] = jj_gen;
2329       jj_consume_token(-1);
2330       throw new ParseException();
2331     }
2332   }
2333
2334   static final public String PrintExpression() throws ParseException {
2335   final StringBuffer buff = new StringBuffer("print ");
2336   final String expr;
2337     jj_consume_token(PRINT);
2338     expr = Expression();
2339     buff.append(expr);
2340     {if (true) return buff.toString();}
2341     throw new Error("Missing return statement in function");
2342   }
2343
2344   static final public String ListExpression() throws ParseException {
2345   final StringBuffer buff = new StringBuffer("list(");
2346   String expr;
2347     jj_consume_token(LIST);
2348     jj_consume_token(LPAREN);
2349     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2350     case DOLLAR:
2351     case DOLLAR_ID:
2352       expr = VariableDeclaratorId();
2353      buff.append(expr);
2354       break;
2355     default:
2356       jj_la1[77] = jj_gen;
2357       ;
2358     }
2359     jj_consume_token(COMMA);
2360    buff.append(",");
2361     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2362     case DOLLAR:
2363     case DOLLAR_ID:
2364       expr = VariableDeclaratorId();
2365      buff.append(expr);
2366       break;
2367     default:
2368       jj_la1[78] = jj_gen;
2369       ;
2370     }
2371    buff.append(")");
2372     jj_consume_token(RPAREN);
2373     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2374     case ASSIGN:
2375       jj_consume_token(ASSIGN);
2376       expr = Expression();
2377                                   buff.append("(").append(expr);
2378       break;
2379     default:
2380       jj_la1[79] = jj_gen;
2381       ;
2382     }
2383    {if (true) return buff.toString();}
2384     throw new Error("Missing return statement in function");
2385   }
2386
2387   static final public void EchoStatement() throws ParseException {
2388     jj_consume_token(ECHO);
2389     Expression();
2390     label_23:
2391     while (true) {
2392       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2393       case COMMA:
2394         ;
2395         break;
2396       default:
2397         jj_la1[80] = jj_gen;
2398         break label_23;
2399       }
2400       jj_consume_token(COMMA);
2401       Expression();
2402     }
2403     try {
2404       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2405       case SEMICOLON:
2406         jj_consume_token(SEMICOLON);
2407         break;
2408       case 138:
2409         jj_consume_token(138);
2410         break;
2411       default:
2412         jj_la1[81] = jj_gen;
2413         jj_consume_token(-1);
2414         throw new ParseException();
2415       }
2416     } catch (ParseException e) {
2417     errorMessage = "';' expected after 'echo' statement";
2418     errorLevel   = ERROR;
2419     {if (true) throw e;}
2420     }
2421   }
2422
2423   static final public void GlobalStatement() throws ParseException {
2424     jj_consume_token(GLOBAL);
2425     VariableDeclaratorId();
2426     label_24:
2427     while (true) {
2428       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2429       case COMMA:
2430         ;
2431         break;
2432       default:
2433         jj_la1[82] = jj_gen;
2434         break label_24;
2435       }
2436       jj_consume_token(COMMA);
2437       VariableDeclaratorId();
2438     }
2439     try {
2440       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2441       case SEMICOLON:
2442         jj_consume_token(SEMICOLON);
2443         break;
2444       case 138:
2445         jj_consume_token(138);
2446         break;
2447       default:
2448         jj_la1[83] = jj_gen;
2449         jj_consume_token(-1);
2450         throw new ParseException();
2451       }
2452     } catch (ParseException e) {
2453     errorMessage = "';' expected";
2454     errorLevel   = ERROR;
2455     {if (true) throw e;}
2456     }
2457   }
2458
2459   static final public void StaticStatement() throws ParseException {
2460     jj_consume_token(STATIC);
2461     VariableDeclarator();
2462     label_25:
2463     while (true) {
2464       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2465       case COMMA:
2466         ;
2467         break;
2468       default:
2469         jj_la1[84] = jj_gen;
2470         break label_25;
2471       }
2472       jj_consume_token(COMMA);
2473       VariableDeclarator();
2474     }
2475     try {
2476       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2477       case SEMICOLON:
2478         jj_consume_token(SEMICOLON);
2479         break;
2480       case 138:
2481         jj_consume_token(138);
2482         break;
2483       default:
2484         jj_la1[85] = jj_gen;
2485         jj_consume_token(-1);
2486         throw new ParseException();
2487       }
2488     } catch (ParseException e) {
2489     errorMessage = "';' expected";
2490     errorLevel   = ERROR;
2491     {if (true) throw e;}
2492     }
2493   }
2494
2495   static final public void LabeledStatement() throws ParseException {
2496     jj_consume_token(IDENTIFIER);
2497     jj_consume_token(COLON);
2498     Statement();
2499   }
2500
2501   static final public void Block() throws ParseException {
2502     try {
2503       jj_consume_token(LBRACE);
2504     } catch (ParseException e) {
2505     errorMessage = "'{' expected";
2506     errorLevel   = ERROR;
2507     {if (true) throw e;}
2508     }
2509     label_26:
2510     while (true) {
2511       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2512       case CLASS:
2513       case FUNCTION:
2514       case IF:
2515       case ARRAY:
2516       case BREAK:
2517       case PRINT:
2518       case ECHO:
2519       case INCLUDE:
2520       case REQUIRE:
2521       case INCLUDE_ONCE:
2522       case REQUIRE_ONCE:
2523       case GLOBAL:
2524       case STATIC:
2525       case LIST:
2526       case CONTINUE:
2527       case DO:
2528       case FOR:
2529       case NEW:
2530       case NULL:
2531       case RETURN:
2532       case SWITCH:
2533       case TRUE:
2534       case FALSE:
2535       case WHILE:
2536       case FOREACH:
2537       case INTEGER_LITERAL:
2538       case FLOATING_POINT_LITERAL:
2539       case STRING_LITERAL:
2540       case IDENTIFIER:
2541       case LPAREN:
2542       case LBRACE:
2543       case SEMICOLON:
2544       case AT:
2545       case DOLLAR:
2546       case BANG:
2547       case INCR:
2548       case DECR:
2549       case PLUS:
2550       case MINUS:
2551       case BIT_AND:
2552       case DOLLAR_ID:
2553         ;
2554         break;
2555       default:
2556         jj_la1[86] = jj_gen;
2557         break label_26;
2558       }
2559       BlockStatement();
2560     }
2561     try {
2562       jj_consume_token(RBRACE);
2563     } catch (ParseException e) {
2564     errorMessage = "unexpected token : "+ e.currentToken.image +", '}' expected";
2565     errorLevel   = ERROR;
2566     {if (true) throw e;}
2567     }
2568   }
2569
2570   static final public void BlockStatement() throws ParseException {
2571     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2572     case IF:
2573     case ARRAY:
2574     case BREAK:
2575     case PRINT:
2576     case ECHO:
2577     case INCLUDE:
2578     case REQUIRE:
2579     case INCLUDE_ONCE:
2580     case REQUIRE_ONCE:
2581     case GLOBAL:
2582     case STATIC:
2583     case LIST:
2584     case CONTINUE:
2585     case DO:
2586     case FOR:
2587     case NEW:
2588     case NULL:
2589     case RETURN:
2590     case SWITCH:
2591     case TRUE:
2592     case FALSE:
2593     case WHILE:
2594     case FOREACH:
2595     case INTEGER_LITERAL:
2596     case FLOATING_POINT_LITERAL:
2597     case STRING_LITERAL:
2598     case IDENTIFIER:
2599     case LPAREN:
2600     case LBRACE:
2601     case SEMICOLON:
2602     case AT:
2603     case DOLLAR:
2604     case BANG:
2605     case INCR:
2606     case DECR:
2607     case PLUS:
2608     case MINUS:
2609     case BIT_AND:
2610     case DOLLAR_ID:
2611       Statement();
2612       break;
2613     case CLASS:
2614       ClassDeclaration();
2615       break;
2616     case FUNCTION:
2617       MethodDeclaration();
2618       break;
2619     default:
2620       jj_la1[87] = jj_gen;
2621       jj_consume_token(-1);
2622       throw new ParseException();
2623     }
2624   }
2625
2626   static final public void BlockStatementNoBreak() throws ParseException {
2627     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2628     case IF:
2629     case ARRAY:
2630     case PRINT:
2631     case ECHO:
2632     case INCLUDE:
2633     case REQUIRE:
2634     case INCLUDE_ONCE:
2635     case REQUIRE_ONCE:
2636     case GLOBAL:
2637     case STATIC:
2638     case LIST:
2639     case CONTINUE:
2640     case DO:
2641     case FOR:
2642     case NEW:
2643     case NULL:
2644     case RETURN:
2645     case SWITCH:
2646     case TRUE:
2647     case FALSE:
2648     case WHILE:
2649     case FOREACH:
2650     case INTEGER_LITERAL:
2651     case FLOATING_POINT_LITERAL:
2652     case STRING_LITERAL:
2653     case IDENTIFIER:
2654     case LPAREN:
2655     case LBRACE:
2656     case SEMICOLON:
2657     case AT:
2658     case DOLLAR:
2659     case BANG:
2660     case INCR:
2661     case DECR:
2662     case PLUS:
2663     case MINUS:
2664     case BIT_AND:
2665     case DOLLAR_ID:
2666       StatementNoBreak();
2667       break;
2668     case CLASS:
2669       ClassDeclaration();
2670       break;
2671     case FUNCTION:
2672       MethodDeclaration();
2673       break;
2674     default:
2675       jj_la1[88] = jj_gen;
2676       jj_consume_token(-1);
2677       throw new ParseException();
2678     }
2679   }
2680
2681   static final public void LocalVariableDeclaration() throws ParseException {
2682     LocalVariableDeclarator();
2683     label_27:
2684     while (true) {
2685       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2686       case COMMA:
2687         ;
2688         break;
2689       default:
2690         jj_la1[89] = jj_gen;
2691         break label_27;
2692       }
2693       jj_consume_token(COMMA);
2694       LocalVariableDeclarator();
2695     }
2696   }
2697
2698   static final public void LocalVariableDeclarator() throws ParseException {
2699     VariableDeclaratorId();
2700     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2701     case ASSIGN:
2702       jj_consume_token(ASSIGN);
2703       Expression();
2704       break;
2705     default:
2706       jj_la1[90] = jj_gen;
2707       ;
2708     }
2709   }
2710
2711   static final public void EmptyStatement() throws ParseException {
2712     jj_consume_token(SEMICOLON);
2713   }
2714
2715   static final public void StatementExpression() throws ParseException {
2716     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2717     case INCR:
2718       PreIncrementExpression();
2719       break;
2720     case DECR:
2721       PreDecrementExpression();
2722       break;
2723     case ARRAY:
2724     case NEW:
2725     case IDENTIFIER:
2726     case DOLLAR:
2727     case DOLLAR_ID:
2728       PrimaryExpression();
2729       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2730       case ASSIGN:
2731       case PLUSASSIGN:
2732       case MINUSASSIGN:
2733       case STARASSIGN:
2734       case SLASHASSIGN:
2735       case ANDASSIGN:
2736       case ORASSIGN:
2737       case XORASSIGN:
2738       case DOTASSIGN:
2739       case REMASSIGN:
2740       case TILDEEQUAL:
2741       case INCR:
2742       case DECR:
2743       case LSHIFTASSIGN:
2744       case RSIGNEDSHIFTASSIGN:
2745         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2746         case INCR:
2747           jj_consume_token(INCR);
2748           break;
2749         case DECR:
2750           jj_consume_token(DECR);
2751           break;
2752         case ASSIGN:
2753         case PLUSASSIGN:
2754         case MINUSASSIGN:
2755         case STARASSIGN:
2756         case SLASHASSIGN:
2757         case ANDASSIGN:
2758         case ORASSIGN:
2759         case XORASSIGN:
2760         case DOTASSIGN:
2761         case REMASSIGN:
2762         case TILDEEQUAL:
2763         case LSHIFTASSIGN:
2764         case RSIGNEDSHIFTASSIGN:
2765           AssignmentOperator();
2766           Expression();
2767           break;
2768         default:
2769           jj_la1[91] = jj_gen;
2770           jj_consume_token(-1);
2771           throw new ParseException();
2772         }
2773         break;
2774       default:
2775         jj_la1[92] = jj_gen;
2776         ;
2777       }
2778       break;
2779     default:
2780       jj_la1[93] = jj_gen;
2781       jj_consume_token(-1);
2782       throw new ParseException();
2783     }
2784   }
2785
2786   static final public void SwitchStatement() throws ParseException {
2787   Token breakToken = null;
2788   int line;
2789     jj_consume_token(SWITCH);
2790     try {
2791       jj_consume_token(LPAREN);
2792     } catch (ParseException e) {
2793     errorMessage = "'(' expected after 'switch'";
2794     errorLevel   = ERROR;
2795     {if (true) throw e;}
2796     }
2797     Expression();
2798     try {
2799       jj_consume_token(RPAREN);
2800     } catch (ParseException e) {
2801     errorMessage = "')' expected";
2802     errorLevel   = ERROR;
2803     {if (true) throw e;}
2804     }
2805     try {
2806       jj_consume_token(LBRACE);
2807     } catch (ParseException e) {
2808     errorMessage = "'{' expected";
2809     errorLevel   = ERROR;
2810     {if (true) throw e;}
2811     }
2812     label_28:
2813     while (true) {
2814       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2815       case CASE:
2816       case _DEFAULT:
2817         ;
2818         break;
2819       default:
2820         jj_la1[94] = jj_gen;
2821         break label_28;
2822       }
2823       line = SwitchLabel();
2824       label_29:
2825       while (true) {
2826         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2827         case CLASS:
2828         case FUNCTION:
2829         case IF:
2830         case ARRAY:
2831         case PRINT:
2832         case ECHO:
2833         case INCLUDE:
2834         case REQUIRE:
2835         case INCLUDE_ONCE:
2836         case REQUIRE_ONCE:
2837         case GLOBAL:
2838         case STATIC:
2839         case LIST:
2840         case CONTINUE:
2841         case DO:
2842         case FOR:
2843         case NEW:
2844         case NULL:
2845         case RETURN:
2846         case SWITCH:
2847         case TRUE:
2848         case FALSE:
2849         case WHILE:
2850         case FOREACH:
2851         case INTEGER_LITERAL:
2852         case FLOATING_POINT_LITERAL:
2853         case STRING_LITERAL:
2854         case IDENTIFIER:
2855         case LPAREN:
2856         case LBRACE:
2857         case SEMICOLON:
2858         case AT:
2859         case DOLLAR:
2860         case BANG:
2861         case INCR:
2862         case DECR:
2863         case PLUS:
2864         case MINUS:
2865         case BIT_AND:
2866         case DOLLAR_ID:
2867           ;
2868           break;
2869         default:
2870           jj_la1[95] = jj_gen;
2871           break label_29;
2872         }
2873         BlockStatementNoBreak();
2874       }
2875       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2876       case BREAK:
2877         breakToken = jj_consume_token(BREAK);
2878         try {
2879           jj_consume_token(SEMICOLON);
2880         } catch (ParseException e) {
2881           errorMessage = "';' expected after 'break' keyword";
2882           errorLevel   = ERROR;
2883           {if (true) throw e;}
2884         }
2885         break;
2886       default:
2887         jj_la1[96] = jj_gen;
2888         ;
2889       }
2890         try {
2891           if (breakToken == null) {
2892             setMarker(fileToParse,
2893                       "You should use put a 'break' at the end of your statement",
2894                       line,
2895                       INFO,
2896                       "Line " + line);
2897           }
2898         } catch (CoreException e) {
2899           PHPeclipsePlugin.log(e);
2900         }
2901     }
2902     try {
2903       jj_consume_token(RBRACE);
2904     } catch (ParseException e) {
2905     errorMessage = "'}' expected";
2906     errorLevel   = ERROR;
2907     {if (true) throw e;}
2908     }
2909   }
2910
2911   static final public int SwitchLabel() throws ParseException {
2912   final Token token;
2913     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2914     case CASE:
2915       token = jj_consume_token(CASE);
2916       try {
2917         Expression();
2918       } catch (ParseException e) {
2919     if (errorMessage != null) {if (true) throw e;}
2920     errorMessage = "expression expected after 'case' keyword";
2921     errorLevel   = ERROR;
2922     {if (true) throw e;}
2923       }
2924       try {
2925         jj_consume_token(COLON);
2926       } catch (ParseException e) {
2927     errorMessage = "':' expected after case expression";
2928     errorLevel   = ERROR;
2929     {if (true) throw e;}
2930       }
2931    {if (true) return token.beginLine;}
2932       break;
2933     case _DEFAULT:
2934       token = jj_consume_token(_DEFAULT);
2935       try {
2936         jj_consume_token(COLON);
2937       } catch (ParseException e) {
2938     errorMessage = "':' expected after 'default' keyword";
2939     errorLevel   = ERROR;
2940     {if (true) throw e;}
2941       }
2942    {if (true) return token.beginLine;}
2943       break;
2944     default:
2945       jj_la1[97] = jj_gen;
2946       jj_consume_token(-1);
2947       throw new ParseException();
2948     }
2949     throw new Error("Missing return statement in function");
2950   }
2951
2952   static final public void IfStatement() throws ParseException {
2953   final Token token;
2954   final int pos = jj_input_stream.bufpos;
2955     token = jj_consume_token(IF);
2956     Condition("if");
2957     IfStatement0(pos,pos+token.image.length());
2958   }
2959
2960   static final public void Condition(final String keyword) throws ParseException {
2961     try {
2962       jj_consume_token(LPAREN);
2963     } catch (ParseException e) {
2964     errorMessage = "'(' expected after " + keyword + " keyword";
2965     errorLevel   = ERROR;
2966     {if (true) throw e;}
2967     }
2968     Expression();
2969     try {
2970       jj_consume_token(RPAREN);
2971     } catch (ParseException e) {
2972     errorMessage = "')' expected after " + keyword + " keyword";
2973     errorLevel   = ERROR;
2974     {if (true) throw e;}
2975     }
2976   }
2977
2978   static final public void IfStatement0(final int start,final int end) throws ParseException {
2979     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2980     case COLON:
2981       jj_consume_token(COLON);
2982       label_30:
2983       while (true) {
2984         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2985         case IF:
2986         case ARRAY:
2987         case BREAK:
2988         case PRINT:
2989         case ECHO:
2990         case INCLUDE:
2991         case REQUIRE:
2992         case INCLUDE_ONCE:
2993         case REQUIRE_ONCE:
2994         case GLOBAL:
2995         case STATIC:
2996         case LIST:
2997         case CONTINUE:
2998         case DO:
2999         case FOR:
3000         case NEW:
3001         case NULL:
3002         case RETURN:
3003         case SWITCH:
3004         case TRUE:
3005         case FALSE:
3006         case WHILE:
3007         case FOREACH:
3008         case INTEGER_LITERAL:
3009         case FLOATING_POINT_LITERAL:
3010         case STRING_LITERAL:
3011         case IDENTIFIER:
3012         case LPAREN:
3013         case LBRACE:
3014         case SEMICOLON:
3015         case AT:
3016         case DOLLAR:
3017         case BANG:
3018         case INCR:
3019         case DECR:
3020         case PLUS:
3021         case MINUS:
3022         case BIT_AND:
3023         case DOLLAR_ID:
3024           ;
3025           break;
3026         default:
3027           jj_la1[98] = jj_gen;
3028           break label_30;
3029         }
3030         Statement();
3031       }
3032       label_31:
3033       while (true) {
3034         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3035         case ELSEIF:
3036           ;
3037           break;
3038         default:
3039           jj_la1[99] = jj_gen;
3040           break label_31;
3041         }
3042         ElseIfStatementColon();
3043       }
3044       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3045       case ELSE:
3046         ElseStatementColon();
3047         break;
3048       default:
3049         jj_la1[100] = jj_gen;
3050         ;
3051       }
3052    try {
3053   setMarker(fileToParse,
3054             "Ugly syntax detected, you should if () {...} instead of if (): ... endif;",
3055             start,
3056             end,
3057             INFO,
3058             "Line " + token.beginLine);
3059   } catch (CoreException e) {
3060     PHPeclipsePlugin.log(e);
3061   }
3062       try {
3063         jj_consume_token(ENDIF);
3064       } catch (ParseException e) {
3065     errorMessage = "'endif' expected";
3066     errorLevel   = ERROR;
3067     {if (true) throw e;}
3068       }
3069       try {
3070         jj_consume_token(SEMICOLON);
3071       } catch (ParseException e) {
3072     errorMessage = "';' expected after 'endif' keyword";
3073     errorLevel   = ERROR;
3074     {if (true) throw e;}
3075       }
3076       break;
3077     case IF:
3078     case ARRAY:
3079     case BREAK:
3080     case PRINT:
3081     case ECHO:
3082     case INCLUDE:
3083     case REQUIRE:
3084     case INCLUDE_ONCE:
3085     case REQUIRE_ONCE:
3086     case GLOBAL:
3087     case STATIC:
3088     case LIST:
3089     case CONTINUE:
3090     case DO:
3091     case FOR:
3092     case NEW:
3093     case NULL:
3094     case RETURN:
3095     case SWITCH:
3096     case TRUE:
3097     case FALSE:
3098     case WHILE:
3099     case FOREACH:
3100     case INTEGER_LITERAL:
3101     case FLOATING_POINT_LITERAL:
3102     case STRING_LITERAL:
3103     case IDENTIFIER:
3104     case LPAREN:
3105     case LBRACE:
3106     case SEMICOLON:
3107     case AT:
3108     case DOLLAR:
3109     case BANG:
3110     case INCR:
3111     case DECR:
3112     case PLUS:
3113     case MINUS:
3114     case BIT_AND:
3115     case DOLLAR_ID:
3116       Statement();
3117       label_32:
3118       while (true) {
3119         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3120         case ELSEIF:
3121           ;
3122           break;
3123         default:
3124           jj_la1[101] = jj_gen;
3125           break label_32;
3126         }
3127         ElseIfStatement();
3128       }
3129       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3130       case ELSE:
3131         jj_consume_token(ELSE);
3132         Statement();
3133         break;
3134       default:
3135         jj_la1[102] = jj_gen;
3136         ;
3137       }
3138       break;
3139     default:
3140       jj_la1[103] = jj_gen;
3141       jj_consume_token(-1);
3142       throw new ParseException();
3143     }
3144   }
3145
3146   static final public void ElseIfStatementColon() throws ParseException {
3147     jj_consume_token(ELSEIF);
3148     Condition("elseif");
3149     jj_consume_token(COLON);
3150     label_33:
3151     while (true) {
3152       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3153       case IF:
3154       case ARRAY:
3155       case BREAK:
3156       case PRINT:
3157       case ECHO:
3158       case INCLUDE:
3159       case REQUIRE:
3160       case INCLUDE_ONCE:
3161       case REQUIRE_ONCE:
3162       case GLOBAL:
3163       case STATIC:
3164       case LIST:
3165       case CONTINUE:
3166       case DO:
3167       case FOR:
3168       case NEW:
3169       case NULL:
3170       case RETURN:
3171       case SWITCH:
3172       case TRUE:
3173       case FALSE:
3174       case WHILE:
3175       case FOREACH:
3176       case INTEGER_LITERAL:
3177       case FLOATING_POINT_LITERAL:
3178       case STRING_LITERAL:
3179       case IDENTIFIER:
3180       case LPAREN:
3181       case LBRACE:
3182       case SEMICOLON:
3183       case AT:
3184       case DOLLAR:
3185       case BANG:
3186       case INCR:
3187       case DECR:
3188       case PLUS:
3189       case MINUS:
3190       case BIT_AND:
3191       case DOLLAR_ID:
3192         ;
3193         break;
3194       default:
3195         jj_la1[104] = jj_gen;
3196         break label_33;
3197       }
3198       Statement();
3199     }
3200   }
3201
3202   static final public void ElseStatementColon() throws ParseException {
3203     jj_consume_token(ELSE);
3204     jj_consume_token(COLON);
3205     label_34:
3206     while (true) {
3207       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3208       case IF:
3209       case ARRAY:
3210       case BREAK:
3211       case PRINT:
3212       case ECHO:
3213       case INCLUDE:
3214       case REQUIRE:
3215       case INCLUDE_ONCE:
3216       case REQUIRE_ONCE:
3217       case GLOBAL:
3218       case STATIC:
3219       case LIST:
3220       case CONTINUE:
3221       case DO:
3222       case FOR:
3223       case NEW:
3224       case NULL:
3225       case RETURN:
3226       case SWITCH:
3227       case TRUE:
3228       case FALSE:
3229       case WHILE:
3230       case FOREACH:
3231       case INTEGER_LITERAL:
3232       case FLOATING_POINT_LITERAL:
3233       case STRING_LITERAL:
3234       case IDENTIFIER:
3235       case LPAREN:
3236       case LBRACE:
3237       case SEMICOLON:
3238       case AT:
3239       case DOLLAR:
3240       case BANG:
3241       case INCR:
3242       case DECR:
3243       case PLUS:
3244       case MINUS:
3245       case BIT_AND:
3246       case DOLLAR_ID:
3247         ;
3248         break;
3249       default:
3250         jj_la1[105] = jj_gen;
3251         break label_34;
3252       }
3253       Statement();
3254     }
3255   }
3256
3257   static final public void ElseIfStatement() throws ParseException {
3258     jj_consume_token(ELSEIF);
3259     Condition("elseif");
3260     Statement();
3261   }
3262
3263   static final public void WhileStatement() throws ParseException {
3264   final Token token;
3265   final int pos = jj_input_stream.bufpos;
3266     token = jj_consume_token(WHILE);
3267     Condition("while");
3268     WhileStatement0(pos,pos + token.image.length());
3269   }
3270
3271   static final public void WhileStatement0(final int start, final int end) throws ParseException {
3272     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3273     case COLON:
3274       jj_consume_token(COLON);
3275       label_35:
3276       while (true) {
3277         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3278         case IF:
3279         case ARRAY:
3280         case BREAK:
3281         case PRINT:
3282         case ECHO:
3283         case INCLUDE:
3284         case REQUIRE:
3285         case INCLUDE_ONCE:
3286         case REQUIRE_ONCE:
3287         case GLOBAL:
3288         case STATIC:
3289         case LIST:
3290         case CONTINUE:
3291         case DO:
3292         case FOR:
3293         case NEW:
3294         case NULL:
3295         case RETURN:
3296         case SWITCH:
3297         case TRUE:
3298         case FALSE:
3299         case WHILE:
3300         case FOREACH:
3301         case INTEGER_LITERAL:
3302         case FLOATING_POINT_LITERAL:
3303         case STRING_LITERAL:
3304         case IDENTIFIER:
3305         case LPAREN:
3306         case LBRACE:
3307         case SEMICOLON:
3308         case AT:
3309         case DOLLAR:
3310         case BANG:
3311         case INCR:
3312         case DECR:
3313         case PLUS:
3314         case MINUS:
3315         case BIT_AND:
3316         case DOLLAR_ID:
3317           ;
3318           break;
3319         default:
3320           jj_la1[106] = jj_gen;
3321           break label_35;
3322         }
3323         Statement();
3324       }
3325    try {
3326   setMarker(fileToParse,
3327             "Ugly syntax detected, you should while () {...} instead of while (): ... endwhile;",
3328             start,
3329             end,
3330             INFO,
3331             "Line " + token.beginLine);
3332   } catch (CoreException e) {
3333     PHPeclipsePlugin.log(e);
3334   }
3335       try {
3336         jj_consume_token(ENDWHILE);
3337       } catch (ParseException e) {
3338     errorMessage = "'endwhile' expected";
3339     errorLevel   = ERROR;
3340     {if (true) throw e;}
3341       }
3342       try {
3343         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3344         case SEMICOLON:
3345           jj_consume_token(SEMICOLON);
3346           break;
3347         case 138:
3348           jj_consume_token(138);
3349           break;
3350         default:
3351           jj_la1[107] = jj_gen;
3352           jj_consume_token(-1);
3353           throw new ParseException();
3354         }
3355       } catch (ParseException e) {
3356     errorMessage = "';' expected after 'endwhile' keyword";
3357     errorLevel   = ERROR;
3358     {if (true) throw e;}
3359       }
3360       break;
3361     case IF:
3362     case ARRAY:
3363     case BREAK:
3364     case PRINT:
3365     case ECHO:
3366     case INCLUDE:
3367     case REQUIRE:
3368     case INCLUDE_ONCE:
3369     case REQUIRE_ONCE:
3370     case GLOBAL:
3371     case STATIC:
3372     case LIST:
3373     case CONTINUE:
3374     case DO:
3375     case FOR:
3376     case NEW:
3377     case NULL:
3378     case RETURN:
3379     case SWITCH:
3380     case TRUE:
3381     case FALSE:
3382     case WHILE:
3383     case FOREACH:
3384     case INTEGER_LITERAL:
3385     case FLOATING_POINT_LITERAL:
3386     case STRING_LITERAL:
3387     case IDENTIFIER:
3388     case LPAREN:
3389     case LBRACE:
3390     case SEMICOLON:
3391     case AT:
3392     case DOLLAR:
3393     case BANG:
3394     case INCR:
3395     case DECR:
3396     case PLUS:
3397     case MINUS:
3398     case BIT_AND:
3399     case DOLLAR_ID:
3400       Statement();
3401       break;
3402     default:
3403       jj_la1[108] = jj_gen;
3404       jj_consume_token(-1);
3405       throw new ParseException();
3406     }
3407   }
3408
3409   static final public void DoStatement() throws ParseException {
3410     jj_consume_token(DO);
3411     Statement();
3412     jj_consume_token(WHILE);
3413     Condition("while");
3414     try {
3415       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3416       case SEMICOLON:
3417         jj_consume_token(SEMICOLON);
3418         break;
3419       case 138:
3420         jj_consume_token(138);
3421         break;
3422       default:
3423         jj_la1[109] = jj_gen;
3424         jj_consume_token(-1);
3425         throw new ParseException();
3426       }
3427     } catch (ParseException e) {
3428     errorMessage = "';' expected";
3429     errorLevel   = ERROR;
3430     {if (true) throw e;}
3431     }
3432   }
3433
3434   static final public void ForeachStatement() throws ParseException {
3435     jj_consume_token(FOREACH);
3436     try {
3437       jj_consume_token(LPAREN);
3438     } catch (ParseException e) {
3439     errorMessage = "'(' expected after 'foreach' keyword";
3440     errorLevel   = ERROR;
3441     {if (true) throw e;}
3442     }
3443     try {
3444       Variable();
3445     } catch (ParseException e) {
3446     errorMessage = "variable expected";
3447     errorLevel   = ERROR;
3448     {if (true) throw e;}
3449     }
3450     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3451     case CLASSACCESS:
3452     case LBRACKET:
3453       VariableSuffix();
3454       break;
3455     default:
3456       jj_la1[110] = jj_gen;
3457       ;
3458     }
3459     try {
3460       jj_consume_token(AS);
3461     } catch (ParseException e) {
3462     errorMessage = "'as' expected";
3463     errorLevel   = ERROR;
3464     {if (true) throw e;}
3465     }
3466     try {
3467       Variable();
3468     } catch (ParseException e) {
3469     errorMessage = "variable expected";
3470     errorLevel   = ERROR;
3471     {if (true) throw e;}
3472     }
3473     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3474     case ARRAYASSIGN:
3475       jj_consume_token(ARRAYASSIGN);
3476       Expression();
3477       break;
3478     default:
3479       jj_la1[111] = jj_gen;
3480       ;
3481     }
3482     try {
3483       jj_consume_token(RPAREN);
3484     } catch (ParseException e) {
3485     errorMessage = "')' expected after 'foreach' keyword";
3486     errorLevel   = ERROR;
3487     {if (true) throw e;}
3488     }
3489     try {
3490       Statement();
3491     } catch (ParseException e) {
3492     if (errorMessage != null) {if (true) throw e;}
3493     errorMessage = "statement expected";
3494     errorLevel   = ERROR;
3495     {if (true) throw e;}
3496     }
3497   }
3498
3499   static final public void ForStatement() throws ParseException {
3500 final Token token;
3501 final int pos = jj_input_stream.bufpos;
3502     token = jj_consume_token(FOR);
3503     try {
3504       jj_consume_token(LPAREN);
3505     } catch (ParseException e) {
3506     errorMessage = "'(' expected after 'for' keyword";
3507     errorLevel   = ERROR;
3508     {if (true) throw e;}
3509     }
3510     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3511     case ARRAY:
3512     case NEW:
3513     case IDENTIFIER:
3514     case DOLLAR:
3515     case INCR:
3516     case DECR:
3517     case DOLLAR_ID:
3518       ForInit();
3519       break;
3520     default:
3521       jj_la1[112] = jj_gen;
3522       ;
3523     }
3524     jj_consume_token(SEMICOLON);
3525     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3526     case ARRAY:
3527     case PRINT:
3528     case LIST:
3529     case NEW:
3530     case NULL:
3531     case TRUE:
3532     case FALSE:
3533     case INTEGER_LITERAL:
3534     case FLOATING_POINT_LITERAL:
3535     case STRING_LITERAL:
3536     case IDENTIFIER:
3537     case LPAREN:
3538     case AT:
3539     case DOLLAR:
3540     case BANG:
3541     case INCR:
3542     case DECR:
3543     case PLUS:
3544     case MINUS:
3545     case BIT_AND:
3546     case DOLLAR_ID:
3547       Expression();
3548       break;
3549     default:
3550       jj_la1[113] = jj_gen;
3551       ;
3552     }
3553     jj_consume_token(SEMICOLON);
3554     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3555     case ARRAY:
3556     case NEW:
3557     case IDENTIFIER:
3558     case DOLLAR:
3559     case INCR:
3560     case DECR:
3561     case DOLLAR_ID:
3562       StatementExpressionList();
3563       break;
3564     default:
3565       jj_la1[114] = jj_gen;
3566       ;
3567     }
3568     jj_consume_token(RPAREN);
3569     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3570     case IF:
3571     case ARRAY:
3572     case BREAK:
3573     case PRINT:
3574     case ECHO:
3575     case INCLUDE:
3576     case REQUIRE:
3577     case INCLUDE_ONCE:
3578     case REQUIRE_ONCE:
3579     case GLOBAL:
3580     case STATIC:
3581     case LIST:
3582     case CONTINUE:
3583     case DO:
3584     case FOR:
3585     case NEW:
3586     case NULL:
3587     case RETURN:
3588     case SWITCH:
3589     case TRUE:
3590     case FALSE:
3591     case WHILE:
3592     case FOREACH:
3593     case INTEGER_LITERAL:
3594     case FLOATING_POINT_LITERAL:
3595     case STRING_LITERAL:
3596     case IDENTIFIER:
3597     case LPAREN:
3598     case LBRACE:
3599     case SEMICOLON:
3600     case AT:
3601     case DOLLAR:
3602     case BANG:
3603     case INCR:
3604     case DECR:
3605     case PLUS:
3606     case MINUS:
3607     case BIT_AND:
3608     case DOLLAR_ID:
3609       Statement();
3610       break;
3611     case COLON:
3612       jj_consume_token(COLON);
3613       label_36:
3614       while (true) {
3615         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3616         case IF:
3617         case ARRAY:
3618         case BREAK:
3619         case PRINT:
3620         case ECHO:
3621         case INCLUDE:
3622         case REQUIRE:
3623         case INCLUDE_ONCE:
3624         case REQUIRE_ONCE:
3625         case GLOBAL:
3626         case STATIC:
3627         case LIST:
3628         case CONTINUE:
3629         case DO:
3630         case FOR:
3631         case NEW:
3632         case NULL:
3633         case RETURN:
3634         case SWITCH:
3635         case TRUE:
3636         case FALSE:
3637         case WHILE:
3638         case FOREACH:
3639         case INTEGER_LITERAL:
3640         case FLOATING_POINT_LITERAL:
3641         case STRING_LITERAL:
3642         case IDENTIFIER:
3643         case LPAREN:
3644         case LBRACE:
3645         case SEMICOLON:
3646         case AT:
3647         case DOLLAR:
3648         case BANG:
3649         case INCR:
3650         case DECR:
3651         case PLUS:
3652         case MINUS:
3653         case BIT_AND:
3654         case DOLLAR_ID:
3655           ;
3656           break;
3657         default:
3658           jj_la1[115] = jj_gen;
3659           break label_36;
3660         }
3661         Statement();
3662       }
3663         try {
3664         setMarker(fileToParse,
3665                   "Ugly syntax detected, you should for () {...} instead of for (): ... endfor;",
3666                   pos,
3667                   pos+token.image.length(),
3668                   INFO,
3669                   "Line " + token.beginLine);
3670         } catch (CoreException e) {
3671           PHPeclipsePlugin.log(e);
3672         }
3673       try {
3674         jj_consume_token(ENDFOR);
3675       } catch (ParseException e) {
3676         errorMessage = "'endfor' expected";
3677         errorLevel   = ERROR;
3678         {if (true) throw e;}
3679       }
3680       try {
3681         jj_consume_token(SEMICOLON);
3682       } catch (ParseException e) {
3683         errorMessage = "';' expected after 'endfor' keyword";
3684         errorLevel   = ERROR;
3685         {if (true) throw e;}
3686       }
3687       break;
3688     default:
3689       jj_la1[116] = jj_gen;
3690       jj_consume_token(-1);
3691       throw new ParseException();
3692     }
3693   }
3694
3695   static final public void ForInit() throws ParseException {
3696     if (jj_2_7(2147483647)) {
3697       LocalVariableDeclaration();
3698     } else {
3699       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3700       case ARRAY:
3701       case NEW:
3702       case IDENTIFIER:
3703       case DOLLAR:
3704       case INCR:
3705       case DECR:
3706       case DOLLAR_ID:
3707         StatementExpressionList();
3708         break;
3709       default:
3710         jj_la1[117] = jj_gen;
3711         jj_consume_token(-1);
3712         throw new ParseException();
3713       }
3714     }
3715   }
3716
3717   static final public void StatementExpressionList() throws ParseException {
3718     StatementExpression();
3719     label_37:
3720     while (true) {
3721       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3722       case COMMA:
3723         ;
3724         break;
3725       default:
3726         jj_la1[118] = jj_gen;
3727         break label_37;
3728       }
3729       jj_consume_token(COMMA);
3730       StatementExpression();
3731     }
3732   }
3733
3734   static final public void BreakStatement() throws ParseException {
3735     jj_consume_token(BREAK);
3736     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3737     case IDENTIFIER:
3738       jj_consume_token(IDENTIFIER);
3739       break;
3740     default:
3741       jj_la1[119] = jj_gen;
3742       ;
3743     }
3744     try {
3745       jj_consume_token(SEMICOLON);
3746     } catch (ParseException e) {
3747     errorMessage = "';' expected after 'break' statement";
3748     errorLevel   = ERROR;
3749     {if (true) throw e;}
3750     }
3751   }
3752
3753   static final public void ContinueStatement() throws ParseException {
3754     jj_consume_token(CONTINUE);
3755     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3756     case IDENTIFIER:
3757       jj_consume_token(IDENTIFIER);
3758       break;
3759     default:
3760       jj_la1[120] = jj_gen;
3761       ;
3762     }
3763     try {
3764       jj_consume_token(SEMICOLON);
3765     } catch (ParseException e) {
3766     errorMessage = "';' expected after 'continue' statement";
3767     errorLevel   = ERROR;
3768     {if (true) throw e;}
3769     }
3770   }
3771
3772   static final public void ReturnStatement() throws ParseException {
3773     jj_consume_token(RETURN);
3774     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3775     case ARRAY:
3776     case PRINT:
3777     case LIST:
3778     case NEW:
3779     case NULL:
3780     case TRUE:
3781     case FALSE:
3782     case INTEGER_LITERAL:
3783     case FLOATING_POINT_LITERAL:
3784     case STRING_LITERAL:
3785     case IDENTIFIER:
3786     case LPAREN:
3787     case AT:
3788     case DOLLAR:
3789     case BANG:
3790     case INCR:
3791     case DECR:
3792     case PLUS:
3793     case MINUS:
3794     case BIT_AND:
3795     case DOLLAR_ID:
3796       Expression();
3797       break;
3798     default:
3799       jj_la1[121] = jj_gen;
3800       ;
3801     }
3802     try {
3803       jj_consume_token(SEMICOLON);
3804     } catch (ParseException e) {
3805     errorMessage = "';' expected after 'return' statement";
3806     errorLevel   = ERROR;
3807     {if (true) throw e;}
3808     }
3809   }
3810
3811   static final private boolean jj_2_1(int xla) {
3812     jj_la = xla; jj_lastpos = jj_scanpos = token;
3813     boolean retval = !jj_3_1();
3814     jj_save(0, xla);
3815     return retval;
3816   }
3817
3818   static final private boolean jj_2_2(int xla) {
3819     jj_la = xla; jj_lastpos = jj_scanpos = token;
3820     boolean retval = !jj_3_2();
3821     jj_save(1, xla);
3822     return retval;
3823   }
3824
3825   static final private boolean jj_2_3(int xla) {
3826     jj_la = xla; jj_lastpos = jj_scanpos = token;
3827     boolean retval = !jj_3_3();
3828     jj_save(2, xla);
3829     return retval;
3830   }
3831
3832   static final private boolean jj_2_4(int xla) {
3833     jj_la = xla; jj_lastpos = jj_scanpos = token;
3834     boolean retval = !jj_3_4();
3835     jj_save(3, xla);
3836     return retval;
3837   }
3838
3839   static final private boolean jj_2_5(int xla) {
3840     jj_la = xla; jj_lastpos = jj_scanpos = token;
3841     boolean retval = !jj_3_5();
3842     jj_save(4, xla);
3843     return retval;
3844   }
3845
3846   static final private boolean jj_2_6(int xla) {
3847     jj_la = xla; jj_lastpos = jj_scanpos = token;
3848     boolean retval = !jj_3_6();
3849     jj_save(5, xla);
3850     return retval;
3851   }
3852
3853   static final private boolean jj_2_7(int xla) {
3854     jj_la = xla; jj_lastpos = jj_scanpos = token;
3855     boolean retval = !jj_3_7();
3856     jj_save(6, xla);
3857     return retval;
3858   }
3859
3860   static final private boolean jj_3R_116() {
3861     Token xsp;
3862     xsp = jj_scanpos;
3863     if (jj_3R_119()) {
3864     jj_scanpos = xsp;
3865     if (jj_3R_120()) {
3866     jj_scanpos = xsp;
3867     if (jj_3R_121()) {
3868     jj_scanpos = xsp;
3869     if (jj_3R_122()) {
3870     jj_scanpos = xsp;
3871     if (jj_3R_123()) return true;
3872     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3873     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3874     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3875     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3876     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3877     if (jj_3R_115()) return true;
3878     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3879     return false;
3880   }
3881
3882   static final private boolean jj_3R_99() {
3883     if (jj_scan_token(LBRACE)) return true;
3884     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3885     if (jj_3R_41()) return true;
3886     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3887     if (jj_scan_token(RBRACE)) return true;
3888     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3889     return false;
3890   }
3891
3892   static final private boolean jj_3R_71() {
3893     if (jj_scan_token(IDENTIFIER)) return true;
3894     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3895     Token xsp;
3896     xsp = jj_scanpos;
3897     if (jj_3R_109()) jj_scanpos = xsp;
3898     else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3899     return false;
3900   }
3901
3902   static final private boolean jj_3R_113() {
3903     if (jj_3R_115()) return true;
3904     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3905     Token xsp;
3906     while (true) {
3907       xsp = jj_scanpos;
3908       if (jj_3R_116()) { jj_scanpos = xsp; break; }
3909       if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3910     }
3911     return false;
3912   }
3913
3914   static final private boolean jj_3R_70() {
3915     if (jj_scan_token(LBRACE)) return true;
3916     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3917     if (jj_3R_41()) return true;
3918     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3919     if (jj_scan_token(RBRACE)) return true;
3920     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3921     return false;
3922   }
3923
3924   static final private boolean jj_3R_62() {
3925     Token xsp;
3926     xsp = jj_scanpos;
3927     if (jj_3R_70()) {
3928     jj_scanpos = xsp;
3929     if (jj_3R_71()) {
3930     jj_scanpos = xsp;
3931     if (jj_3R_72()) {
3932     jj_scanpos = xsp;
3933     if (jj_3R_73()) return true;
3934     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3935     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3936     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3937     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3938     return false;
3939   }
3940
3941   static final private boolean jj_3R_197() {
3942     if (jj_scan_token(COMMA)) return true;
3943     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3944     if (jj_3R_41()) return true;
3945     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3946     return false;
3947   }
3948
3949   static final private boolean jj_3R_196() {
3950     if (jj_3R_41()) return true;
3951     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3952     Token xsp;
3953     while (true) {
3954       xsp = jj_scanpos;
3955       if (jj_3R_197()) { jj_scanpos = xsp; break; }
3956       if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3957     }
3958     return false;
3959   }
3960
3961   static final private boolean jj_3R_94() {
3962     if (jj_scan_token(DOLLAR)) return true;
3963     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3964     if (jj_3R_62()) return true;
3965     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3966     return false;
3967   }
3968
3969   static final private boolean jj_3R_114() {
3970     if (jj_scan_token(BIT_AND)) return true;
3971     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3972     if (jj_3R_113()) 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_93() {
3978     if (jj_scan_token(DOLLAR_ID)) return true;
3979     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3980     Token xsp;
3981     xsp = jj_scanpos;
3982     if (jj_3R_99()) jj_scanpos = xsp;
3983     else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3984     return false;
3985   }
3986
3987   static final private boolean jj_3R_77() {
3988     Token xsp;
3989     xsp = jj_scanpos;
3990     if (jj_3R_93()) {
3991     jj_scanpos = xsp;
3992     if (jj_3R_94()) return true;
3993     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3994     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3995     return false;
3996   }
3997
3998   static final private boolean jj_3R_111() {
3999     if (jj_3R_113()) return true;
4000     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4001     Token xsp;
4002     while (true) {
4003       xsp = jj_scanpos;
4004       if (jj_3R_114()) { jj_scanpos = xsp; break; }
4005       if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4006     }
4007     return false;
4008   }
4009
4010   static final private boolean jj_3R_194() {
4011     if (jj_3R_196()) return true;
4012     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4013     return false;
4014   }
4015
4016   static final private boolean jj_3_1() {
4017     if (jj_3R_38()) return true;
4018     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4019     return false;
4020   }
4021
4022   static final private boolean jj_3R_192() {
4023     if (jj_scan_token(LPAREN)) return true;
4024     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4025     Token xsp;
4026     xsp = jj_scanpos;
4027     if (jj_3R_194()) jj_scanpos = xsp;
4028     else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4029     if (jj_scan_token(RPAREN)) return true;
4030     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4031     return false;
4032   }
4033
4034   static final private boolean jj_3R_112() {
4035     if (jj_scan_token(XOR)) return true;
4036     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4037     if (jj_3R_111()) return true;
4038     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4039     return false;
4040   }
4041
4042   static final private boolean jj_3R_68() {
4043     if (jj_3R_77()) return true;
4044     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4045     Token xsp;
4046     while (true) {
4047       xsp = jj_scanpos;
4048       if (jj_3_1()) { jj_scanpos = xsp; break; }
4049       if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4050     }
4051     return false;
4052   }
4053
4054   static final private boolean jj_3R_107() {
4055     if (jj_3R_111()) return true;
4056     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4057     Token xsp;
4058     while (true) {
4059       xsp = jj_scanpos;
4060       if (jj_3R_112()) { jj_scanpos = xsp; break; }
4061       if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4062     }
4063     return false;
4064   }
4065
4066   static final private boolean jj_3R_175() {
4067     if (jj_scan_token(NULL)) return true;
4068     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4069     return false;
4070   }
4071
4072   static final private boolean jj_3R_182() {
4073     if (jj_scan_token(FALSE)) return true;
4074     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4075     return false;
4076   }
4077
4078   static final private boolean jj_3R_181() {
4079     if (jj_scan_token(TRUE)) return true;
4080     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4081     return false;
4082   }
4083
4084   static final private boolean jj_3R_174() {
4085     Token xsp;
4086     xsp = jj_scanpos;
4087     if (jj_3R_181()) {
4088     jj_scanpos = xsp;
4089     if (jj_3R_182()) return true;
4090     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4091     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4092     return false;
4093   }
4094
4095   static final private boolean jj_3R_108() {
4096     if (jj_scan_token(BIT_OR)) return true;
4097     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4098     if (jj_3R_107()) return true;
4099     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4100     return false;
4101   }
4102
4103   static final private boolean jj_3R_100() {
4104     if (jj_3R_107()) return true;
4105     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4106     Token xsp;
4107     while (true) {
4108       xsp = jj_scanpos;
4109       if (jj_3R_108()) { jj_scanpos = xsp; break; }
4110       if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4111     }
4112     return false;
4113   }
4114
4115   static final private boolean jj_3R_170() {
4116     if (jj_3R_175()) return true;
4117     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4118     return false;
4119   }
4120
4121   static final private boolean jj_3R_169() {
4122     if (jj_3R_174()) return true;
4123     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4124     return false;
4125   }
4126
4127   static final private boolean jj_3R_103() {
4128     if (jj_scan_token(_ANDL)) return true;
4129     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4130     return false;
4131   }
4132
4133   static final private boolean jj_3R_168() {
4134     if (jj_scan_token(STRING_LITERAL)) 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_101() {
4140     if (jj_scan_token(DOT)) return true;
4141     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4142     if (jj_3R_100()) return true;
4143     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4144     return false;
4145   }
4146
4147   static final private boolean jj_3R_167() {
4148     if (jj_scan_token(FLOATING_POINT_LITERAL)) return true;
4149     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4150     return false;
4151   }
4152
4153   static final private boolean jj_3R_95() {
4154     if (jj_3R_100()) return true;
4155     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4156     Token xsp;
4157     while (true) {
4158       xsp = jj_scanpos;
4159       if (jj_3R_101()) { jj_scanpos = xsp; break; }
4160       if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4161     }
4162     return false;
4163   }
4164
4165   static final private boolean jj_3R_163() {
4166     Token xsp;
4167     xsp = jj_scanpos;
4168     if (jj_3R_166()) {
4169     jj_scanpos = xsp;
4170     if (jj_3R_167()) {
4171     jj_scanpos = xsp;
4172     if (jj_3R_168()) {
4173     jj_scanpos = xsp;
4174     if (jj_3R_169()) {
4175     jj_scanpos = xsp;
4176     if (jj_3R_170()) return true;
4177     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4178     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4179     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4180     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4181     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4182     return false;
4183   }
4184
4185   static final private boolean jj_3R_166() {
4186     if (jj_scan_token(INTEGER_LITERAL)) return true;
4187     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4188     return false;
4189   }
4190
4191   static final private boolean jj_3R_63() {
4192     if (jj_3R_41()) return true;
4193     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4194     return false;
4195   }
4196
4197   static final private boolean jj_3R_98() {
4198     if (jj_scan_token(_ORL)) return true;
4199     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4200     return false;
4201   }
4202
4203   static final private boolean jj_3R_102() {
4204     if (jj_scan_token(SC_AND)) return true;
4205     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4206     return false;
4207   }
4208
4209   static final private boolean jj_3R_96() {
4210     Token xsp;
4211     xsp = jj_scanpos;
4212     if (jj_3R_102()) {
4213     jj_scanpos = xsp;
4214     if (jj_3R_103()) return true;
4215     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4216     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4217     if (jj_3R_95()) return true;
4218     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4219     return false;
4220   }
4221
4222   static final private boolean jj_3R_78() {
4223     if (jj_3R_95()) return true;
4224     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4225     Token xsp;
4226     while (true) {
4227       xsp = jj_scanpos;
4228       if (jj_3R_96()) { jj_scanpos = xsp; break; }
4229       if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4230     }
4231     return false;
4232   }
4233
4234   static final private boolean jj_3R_69() {
4235     if (jj_scan_token(ASSIGN)) return true;
4236     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4237     if (jj_3R_41()) return true;
4238     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4239     return false;
4240   }
4241
4242   static final private boolean jj_3R_75() {
4243     if (jj_scan_token(HOOK)) return true;
4244     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4245     if (jj_3R_41()) return true;
4246     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4247     if (jj_scan_token(COLON)) return true;
4248     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4249     if (jj_3R_66()) return true;
4250     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4251     return false;
4252   }
4253
4254   static final private boolean jj_3R_61() {
4255     if (jj_scan_token(COMMA)) return true;
4256     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4257     if (jj_3R_60()) return true;
4258     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4259     return false;
4260   }
4261
4262   static final private boolean jj_3R_47() {
4263     if (jj_scan_token(LBRACKET)) return true;
4264     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4265     Token xsp;
4266     xsp = jj_scanpos;
4267     if (jj_3R_63()) jj_scanpos = xsp;
4268     else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4269     if (jj_scan_token(RBRACKET)) return true;
4270     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4271     return false;
4272   }
4273
4274   static final private boolean jj_3R_46() {
4275     if (jj_scan_token(CLASSACCESS)) return true;
4276     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4277     if (jj_3R_62()) return true;
4278     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4279     return false;
4280   }
4281
4282   static final private boolean jj_3R_38() {
4283     Token xsp;
4284     xsp = jj_scanpos;
4285     if (jj_3R_46()) {
4286     jj_scanpos = xsp;
4287     if (jj_3R_47()) return true;
4288     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4289     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4290     return false;
4291   }
4292
4293   static final private boolean jj_3R_97() {
4294     if (jj_scan_token(SC_OR)) return true;
4295     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4296     return false;
4297   }
4298
4299   static final private boolean jj_3R_189() {
4300     if (jj_3R_38()) return true;
4301     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4302     return false;
4303   }
4304
4305   static final private boolean jj_3R_79() {
4306     Token xsp;
4307     xsp = jj_scanpos;
4308     if (jj_3R_97()) {
4309     jj_scanpos = xsp;
4310     if (jj_3R_98()) return true;
4311     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4312     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4313     if (jj_3R_78()) return true;
4314     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4315     return false;
4316   }
4317
4318   static final private boolean jj_3R_188() {
4319     if (jj_3R_192()) return true;
4320     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4321     return false;
4322   }
4323
4324   static final private boolean jj_3R_184() {
4325     Token xsp;
4326     xsp = jj_scanpos;
4327     if (jj_3R_188()) {
4328     jj_scanpos = xsp;
4329     if (jj_3R_189()) return true;
4330     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4331     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4332     return false;
4333   }
4334
4335   static final private boolean jj_3R_74() {
4336     if (jj_3R_78()) return true;
4337     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4338     Token xsp;
4339     while (true) {
4340       xsp = jj_scanpos;
4341       if (jj_3R_79()) { jj_scanpos = xsp; break; }
4342       if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4343     }
4344     return false;
4345   }
4346
4347   static final private boolean jj_3R_60() {
4348     if (jj_3R_68()) return true;
4349     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4350     Token xsp;
4351     xsp = jj_scanpos;
4352     if (jj_3R_69()) jj_scanpos = xsp;
4353     else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4354     return false;
4355   }
4356
4357   static final private boolean jj_3R_191() {
4358     if (jj_3R_68()) 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_190() {
4364     if (jj_scan_token(IDENTIFIER)) 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_186() {
4370     Token xsp;
4371     xsp = jj_scanpos;
4372     if (jj_3R_190()) {
4373     jj_scanpos = xsp;
4374     if (jj_3R_191()) return true;
4375     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4376     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4377     return false;
4378   }
4379
4380   static final private boolean jj_3R_45() {
4381     if (jj_3R_60()) return true;
4382     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4383     Token xsp;
4384     while (true) {
4385       xsp = jj_scanpos;
4386       if (jj_3R_61()) { jj_scanpos = xsp; break; }
4387       if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4388     }
4389     return false;
4390   }
4391
4392   static final private boolean jj_3R_66() {
4393     if (jj_3R_74()) return true;
4394     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4395     Token xsp;
4396     xsp = jj_scanpos;
4397     if (jj_3R_75()) jj_scanpos = xsp;
4398     else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4399     return false;
4400   }
4401
4402   static final private boolean jj_3_7() {
4403     if (jj_3R_45()) return true;
4404     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4405     return false;
4406   }
4407
4408   static final private boolean jj_3R_178() {
4409     if (jj_3R_68()) return true;
4410     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4411     return false;
4412   }
4413
4414   static final private boolean jj_3R_177() {
4415     if (jj_scan_token(NEW)) return true;
4416     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4417     if (jj_3R_186()) return true;
4418     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4419     return false;
4420   }
4421
4422   static final private boolean jj_3R_180() {
4423     if (jj_scan_token(DECR)) return true;
4424     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4425     return false;
4426   }
4427
4428   static final private boolean jj_3R_176() {
4429     if (jj_scan_token(IDENTIFIER)) return true;
4430     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4431     return false;
4432   }
4433
4434   static final private boolean jj_3R_92() {
4435     if (jj_scan_token(TILDEEQUAL)) return true;
4436     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4437     return false;
4438   }
4439
4440   static final private boolean jj_3R_171() {
4441     Token xsp;
4442     xsp = jj_scanpos;
4443     if (jj_3R_176()) {
4444     jj_scanpos = xsp;
4445     if (jj_3R_177()) {
4446     jj_scanpos = xsp;
4447     if (jj_3R_178()) return true;
4448     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4449     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4450     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4451     return false;
4452   }
4453
4454   static final private boolean jj_3R_91() {
4455     if (jj_scan_token(DOTASSIGN)) return true;
4456     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4457     return false;
4458   }
4459
4460   static final private boolean jj_3R_90() {
4461     if (jj_scan_token(ORASSIGN)) return true;
4462     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4463     return false;
4464   }
4465
4466   static final private boolean jj_3R_89() {
4467     if (jj_scan_token(XORASSIGN)) return true;
4468     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4469     return false;
4470   }
4471
4472   static final private boolean jj_3R_88() {
4473     if (jj_scan_token(ANDASSIGN)) return true;
4474     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4475     return false;
4476   }
4477
4478   static final private boolean jj_3R_87() {
4479     if (jj_scan_token(RSIGNEDSHIFTASSIGN)) return true;
4480     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4481     return false;
4482   }
4483
4484   static final private boolean jj_3R_172() {
4485     if (jj_scan_token(ARRAY)) return true;
4486     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4487     if (jj_3R_185()) return true;
4488     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4489     return false;
4490   }
4491
4492   static final private boolean jj_3R_86() {
4493     if (jj_scan_token(LSHIFTASSIGN)) 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_85() {
4499     if (jj_scan_token(MINUSASSIGN)) return true;
4500     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4501     return false;
4502   }
4503
4504   static final private boolean jj_3R_84() {
4505     if (jj_scan_token(PLUSASSIGN)) return true;
4506     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4507     return false;
4508   }
4509
4510   static final private boolean jj_3R_83() {
4511     if (jj_scan_token(REMASSIGN)) return true;
4512     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4513     return false;
4514   }
4515
4516   static final private boolean jj_3R_179() {
4517     if (jj_scan_token(INCR)) return true;
4518     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4519     return false;
4520   }
4521
4522   static final private boolean jj_3R_165() {
4523     if (jj_3R_172()) return true;
4524     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4525     return false;
4526   }
4527
4528   static final private boolean jj_3R_173() {
4529     Token xsp;
4530     xsp = jj_scanpos;
4531     if (jj_3R_179()) {
4532     jj_scanpos = xsp;
4533     if (jj_3R_180()) return true;
4534     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4535     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4536     return false;
4537   }
4538
4539   static final private boolean jj_3R_183() {
4540     if (jj_3R_184()) return true;
4541     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4542     return false;
4543   }
4544
4545   static final private boolean jj_3R_82() {
4546     if (jj_scan_token(SLASHASSIGN)) return true;
4547     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4548     return false;
4549   }
4550
4551   static final private boolean jj_3R_81() {
4552     if (jj_scan_token(STARASSIGN)) return true;
4553     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4554     return false;
4555   }
4556
4557   static final private boolean jj_3R_164() {
4558     if (jj_3R_171()) return true;
4559     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4560     Token xsp;
4561     while (true) {
4562       xsp = jj_scanpos;
4563       if (jj_3R_183()) { jj_scanpos = xsp; break; }
4564       if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4565     }
4566     return false;
4567   }
4568
4569   static final private boolean jj_3R_80() {
4570     if (jj_scan_token(ASSIGN)) return true;
4571     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4572     return false;
4573   }
4574
4575   static final private boolean jj_3R_76() {
4576     Token xsp;
4577     xsp = jj_scanpos;
4578     if (jj_3R_80()) {
4579     jj_scanpos = xsp;
4580     if (jj_3R_81()) {
4581     jj_scanpos = xsp;
4582     if (jj_3R_82()) {
4583     jj_scanpos = xsp;
4584     if (jj_3R_83()) {
4585     jj_scanpos = xsp;
4586     if (jj_3R_84()) {
4587     jj_scanpos = xsp;
4588     if (jj_3R_85()) {
4589     jj_scanpos = xsp;
4590     if (jj_3R_86()) {
4591     jj_scanpos = xsp;
4592     if (jj_3R_87()) {
4593     jj_scanpos = xsp;
4594     if (jj_3R_88()) {
4595     jj_scanpos = xsp;
4596     if (jj_3R_89()) {
4597     jj_scanpos = xsp;
4598     if (jj_3R_90()) {
4599     jj_scanpos = xsp;
4600     if (jj_3R_91()) {
4601     jj_scanpos = xsp;
4602     if (jj_3R_92()) return true;
4603     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4604     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4605     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4606     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4607     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4608     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4609     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4610     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4611     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4612     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4613     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4614     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4615     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4616     return false;
4617   }
4618
4619   static final private boolean jj_3R_187() {
4620     if (jj_3R_184()) return true;
4621     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4622     return false;
4623   }
4624
4625   static final private boolean jj_3R_44() {
4626     if (jj_scan_token(IDENTIFIER)) return true;
4627     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4628     if (jj_scan_token(COLON)) return true;
4629     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4630     return false;
4631   }
4632
4633   static final private boolean jj_3_4() {
4634     if (jj_scan_token(IDENTIFIER)) return true;
4635     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4636     if (jj_scan_token(STATICCLASSACCESS)) return true;
4637     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4638     if (jj_3R_186()) return true;
4639     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4640     Token xsp;
4641     while (true) {
4642       xsp = jj_scanpos;
4643       if (jj_3R_187()) { jj_scanpos = xsp; break; }
4644       if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4645     }
4646     return false;
4647   }
4648
4649   static final private boolean jj_3R_160() {
4650     Token xsp;
4651     xsp = jj_scanpos;
4652     if (jj_3_4()) {
4653     jj_scanpos = xsp;
4654     if (jj_3R_164()) {
4655     jj_scanpos = xsp;
4656     if (jj_3R_165()) return true;
4657     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4658     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4659     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4660     return false;
4661   }
4662
4663   static final private boolean jj_3R_67() {
4664     if (jj_3R_76()) return true;
4665     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4666     if (jj_3R_41()) return true;
4667     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4668     return false;
4669   }
4670
4671   static final private boolean jj_3R_59() {
4672     if (jj_3R_66()) return true;
4673     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4674     Token xsp;
4675     xsp = jj_scanpos;
4676     if (jj_3R_67()) jj_scanpos = xsp;
4677     else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4678     return false;
4679   }
4680
4681   static final private boolean jj_3R_58() {
4682     if (jj_3R_65()) return true;
4683     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4684     return false;
4685   }
4686
4687   static final private boolean jj_3R_41() {
4688     Token xsp;
4689     xsp = jj_scanpos;
4690     if (jj_3R_57()) {
4691     jj_scanpos = xsp;
4692     if (jj_3R_58()) {
4693     jj_scanpos = xsp;
4694     if (jj_3R_59()) return true;
4695     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4696     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4697     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4698     return false;
4699   }
4700
4701   static final private boolean jj_3R_57() {
4702     if (jj_3R_64()) return true;
4703     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4704     return false;
4705   }
4706
4707   static final private boolean jj_3R_162() {
4708     if (jj_3R_160()) return true;
4709     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4710     Token xsp;
4711     xsp = jj_scanpos;
4712     if (jj_3R_173()) jj_scanpos = xsp;
4713     else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4714     return false;
4715   }
4716
4717   static final private boolean jj_3R_161() {
4718     if (jj_scan_token(LPAREN)) return true;
4719     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4720     if (jj_3R_40()) return true;
4721     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4722     if (jj_scan_token(RPAREN)) return true;
4723     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4724     if (jj_3R_135()) return true;
4725     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4726     return false;
4727   }
4728
4729   static final private boolean jj_3R_56() {
4730     if (jj_scan_token(OBJECT)) return true;
4731     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4732     return false;
4733   }
4734
4735   static final private boolean jj_3R_55() {
4736     if (jj_scan_token(INTEGER)) return true;
4737     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4738     return false;
4739   }
4740
4741   static final private boolean jj_3R_54() {
4742     if (jj_scan_token(INT)) return true;
4743     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4744     return false;
4745   }
4746
4747   static final private boolean jj_3R_53() {
4748     if (jj_scan_token(FLOAT)) return true;
4749     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4750     return false;
4751   }
4752
4753   static final private boolean jj_3R_52() {
4754     if (jj_scan_token(DOUBLE)) return true;
4755     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4756     return false;
4757   }
4758
4759   static final private boolean jj_3R_106() {
4760     if (jj_scan_token(ASSIGN)) return true;
4761     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4762     if (jj_3R_41()) return true;
4763     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4764     return false;
4765   }
4766
4767   static final private boolean jj_3_3() {
4768     if (jj_scan_token(LPAREN)) return true;
4769     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4770     if (jj_3R_40()) return true;
4771     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4772     if (jj_scan_token(RPAREN)) return true;
4773     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4774     return false;
4775   }
4776
4777   static final private boolean jj_3R_51() {
4778     if (jj_scan_token(REAL)) return true;
4779     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4780     return false;
4781   }
4782
4783   static final private boolean jj_3R_159() {
4784     if (jj_scan_token(LPAREN)) return true;
4785     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4786     if (jj_3R_41()) return true;
4787     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_50() {
4794     if (jj_scan_token(BOOLEAN)) return true;
4795     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4796     return false;
4797   }
4798
4799   static final private boolean jj_3R_158() {
4800     if (jj_3R_163()) return true;
4801     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4802     return false;
4803   }
4804
4805   static final private boolean jj_3R_105() {
4806     if (jj_3R_68()) return true;
4807     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4808     return false;
4809   }
4810
4811   static final private boolean jj_3R_49() {
4812     if (jj_scan_token(BOOL)) return true;
4813     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4814     return false;
4815   }
4816
4817   static final private boolean jj_3R_157() {
4818     if (jj_3R_162()) return true;
4819     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4820     return false;
4821   }
4822
4823   static final private boolean jj_3R_40() {
4824     Token xsp;
4825     xsp = jj_scanpos;
4826     if (jj_3R_48()) {
4827     jj_scanpos = xsp;
4828     if (jj_3R_49()) {
4829     jj_scanpos = xsp;
4830     if (jj_3R_50()) {
4831     jj_scanpos = xsp;
4832     if (jj_3R_51()) {
4833     jj_scanpos = xsp;
4834     if (jj_3R_52()) {
4835     jj_scanpos = xsp;
4836     if (jj_3R_53()) {
4837     jj_scanpos = xsp;
4838     if (jj_3R_54()) {
4839     jj_scanpos = xsp;
4840     if (jj_3R_55()) {
4841     jj_scanpos = xsp;
4842     if (jj_3R_56()) return true;
4843     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4844     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4845     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4846     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4847     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4848     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4849     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4850     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4851     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4852     return false;
4853   }
4854
4855   static final private boolean jj_3R_48() {
4856     if (jj_scan_token(STRING)) return true;
4857     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4858     return false;
4859   }
4860
4861   static final private boolean jj_3R_104() {
4862     if (jj_3R_68()) return true;
4863     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4864     return false;
4865   }
4866
4867   static final private boolean jj_3R_156() {
4868     if (jj_3R_161()) return true;
4869     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4870     return false;
4871   }
4872
4873   static final private boolean jj_3R_154() {
4874     Token xsp;
4875     xsp = jj_scanpos;
4876     if (jj_3R_155()) {
4877     jj_scanpos = xsp;
4878     if (jj_3R_156()) {
4879     jj_scanpos = xsp;
4880     if (jj_3R_157()) {
4881     jj_scanpos = xsp;
4882     if (jj_3R_158()) {
4883     jj_scanpos = xsp;
4884     if (jj_3R_159()) return true;
4885     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4886     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4887     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4888     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4889     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4890     return false;
4891   }
4892
4893   static final private boolean jj_3R_155() {
4894     if (jj_scan_token(BANG)) return true;
4895     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4896     if (jj_3R_135()) return true;
4897     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4898     return false;
4899   }
4900
4901   static final private boolean jj_3R_65() {
4902     if (jj_scan_token(LIST)) return true;
4903     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4904     if (jj_scan_token(LPAREN)) return true;
4905     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4906     Token xsp;
4907     xsp = jj_scanpos;
4908     if (jj_3R_104()) jj_scanpos = xsp;
4909     else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4910     if (jj_scan_token(COMMA)) return true;
4911     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4912     xsp = jj_scanpos;
4913     if (jj_3R_105()) jj_scanpos = xsp;
4914     else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4915     if (jj_scan_token(RPAREN)) return true;
4916     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4917     xsp = jj_scanpos;
4918     if (jj_3R_106()) jj_scanpos = xsp;
4919     else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4920     return false;
4921   }
4922
4923   static final private boolean jj_3R_153() {
4924     if (jj_scan_token(DECR)) return true;
4925     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4926     if (jj_3R_160()) return true;
4927     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4928     return false;
4929   }
4930
4931   static final private boolean jj_3R_64() {
4932     if (jj_scan_token(PRINT)) return true;
4933     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4934     if (jj_3R_41()) return true;
4935     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4936     return false;
4937   }
4938
4939   static final private boolean jj_3R_152() {
4940     if (jj_scan_token(INCR)) return true;
4941     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4942     if (jj_3R_160()) return true;
4943     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4944     return false;
4945   }
4946
4947   static final private boolean jj_3R_151() {
4948     if (jj_scan_token(MINUS)) return true;
4949     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4950     return false;
4951   }
4952
4953   static final private boolean jj_3R_149() {
4954     if (jj_3R_154()) return true;
4955     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4956     return false;
4957   }
4958
4959   static final private boolean jj_3R_148() {
4960     if (jj_3R_153()) return true;
4961     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4962     return false;
4963   }
4964
4965   static final private boolean jj_3R_143() {
4966     if (jj_scan_token(REM)) return true;
4967     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4968     return false;
4969   }
4970
4971   static final private boolean jj_3R_147() {
4972     if (jj_3R_152()) return true;
4973     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4974     return false;
4975   }
4976
4977   static final private boolean jj_3R_150() {
4978     if (jj_scan_token(PLUS)) return true;
4979     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4980     return false;
4981   }
4982
4983   static final private boolean jj_3R_144() {
4984     Token xsp;
4985     xsp = jj_scanpos;
4986     if (jj_3R_146()) {
4987     jj_scanpos = xsp;
4988     if (jj_3R_147()) {
4989     jj_scanpos = xsp;
4990     if (jj_3R_148()) {
4991     jj_scanpos = xsp;
4992     if (jj_3R_149()) return true;
4993     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4994     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4995     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4996     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4997     return false;
4998   }
4999
5000   static final private boolean jj_3R_146() {
5001     Token xsp;
5002     xsp = jj_scanpos;
5003     if (jj_3R_150()) {
5004     jj_scanpos = xsp;
5005     if (jj_3R_151()) return true;
5006     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5007     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5008     if (jj_3R_135()) return true;
5009     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5010     return false;
5011   }
5012
5013   static final private boolean jj_3R_145() {
5014     if (jj_scan_token(AT)) return true;
5015     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5016     return false;
5017   }
5018
5019   static final private boolean jj_3R_140() {
5020     Token xsp;
5021     while (true) {
5022       xsp = jj_scanpos;
5023       if (jj_3R_145()) { jj_scanpos = xsp; break; }
5024       if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5025     }
5026     if (jj_3R_144()) return true;
5027     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5028     return false;
5029   }
5030
5031   static final private boolean jj_3R_142() {
5032     if (jj_scan_token(SLASH)) return true;
5033     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5034     return false;
5035   }
5036
5037   static final private boolean jj_3R_135() {
5038     Token xsp;
5039     xsp = jj_scanpos;
5040     if (jj_3R_139()) {
5041     jj_scanpos = xsp;
5042     if (jj_3R_140()) return true;
5043     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5044     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5045     return false;
5046   }
5047
5048   static final private boolean jj_3R_139() {
5049     if (jj_scan_token(BIT_AND)) return true;
5050     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5051     if (jj_3R_144()) return true;
5052     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5053     return false;
5054   }
5055
5056   static final private boolean jj_3R_134() {
5057     if (jj_scan_token(RUNSIGNEDSHIFT)) return true;
5058     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5059     return false;
5060   }
5061
5062   static final private boolean jj_3R_138() {
5063     if (jj_scan_token(MINUS)) return true;
5064     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5065     return false;
5066   }
5067
5068   static final private boolean jj_3R_129() {
5069     if (jj_scan_token(GE)) return true;
5070     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5071     return false;
5072   }
5073
5074   static final private boolean jj_3R_141() {
5075     if (jj_scan_token(STAR)) return true;
5076     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5077     return false;
5078   }
5079
5080   static final private boolean jj_3R_136() {
5081     Token xsp;
5082     xsp = jj_scanpos;
5083     if (jj_3R_141()) {
5084     jj_scanpos = xsp;
5085     if (jj_3R_142()) {
5086     jj_scanpos = xsp;
5087     if (jj_3R_143()) return true;
5088     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5089     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5090     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5091     if (jj_3R_135()) return true;
5092     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5093     return false;
5094   }
5095
5096   static final private boolean jj_3R_130() {
5097     if (jj_3R_135()) return true;
5098     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5099     Token xsp;
5100     while (true) {
5101       xsp = jj_scanpos;
5102       if (jj_3R_136()) { jj_scanpos = xsp; break; }
5103       if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5104     }
5105     return false;
5106   }
5107
5108   static final private boolean jj_3_2() {
5109     if (jj_scan_token(COMMA)) return true;
5110     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5111     if (jj_3R_39()) return true;
5112     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5113     return false;
5114   }
5115
5116   static final private boolean jj_3R_193() {
5117     if (jj_3R_39()) return true;
5118     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5119     Token xsp;
5120     while (true) {
5121       xsp = jj_scanpos;
5122       if (jj_3_2()) { jj_scanpos = xsp; break; }
5123       if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5124     }
5125     return false;
5126   }
5127
5128   static final private boolean jj_3R_133() {
5129     if (jj_scan_token(RSIGNEDSHIFT)) 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_128() {
5135     if (jj_scan_token(LE)) return true;
5136     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5137     return false;
5138   }
5139
5140   static final private boolean jj_3R_137() {
5141     if (jj_scan_token(PLUS)) return true;
5142     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5143     return false;
5144   }
5145
5146   static final private boolean jj_3R_131() {
5147     Token xsp;
5148     xsp = jj_scanpos;
5149     if (jj_3R_137()) {
5150     jj_scanpos = xsp;
5151     if (jj_3R_138()) return true;
5152     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5153     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5154     if (jj_3R_130()) return true;
5155     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5156     return false;
5157   }
5158
5159   static final private boolean jj_3R_185() {
5160     if (jj_scan_token(LPAREN)) return true;
5161     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5162     Token xsp;
5163     xsp = jj_scanpos;
5164     if (jj_3R_193()) jj_scanpos = xsp;
5165     else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5166     if (jj_scan_token(RPAREN)) return true;
5167     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5168     return false;
5169   }
5170
5171   static final private boolean jj_3R_124() {
5172     if (jj_3R_130()) return true;
5173     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5174     Token xsp;
5175     while (true) {
5176       xsp = jj_scanpos;
5177       if (jj_3R_131()) { jj_scanpos = xsp; break; }
5178       if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5179     }
5180     return false;
5181   }
5182
5183   static final private boolean jj_3R_195() {
5184     if (jj_scan_token(ARRAYASSIGN)) return true;
5185     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5186     if (jj_3R_41()) return true;
5187     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5188     return false;
5189   }
5190
5191   static final private boolean jj_3R_39() {
5192     if (jj_3R_41()) return true;
5193     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5194     Token xsp;
5195     xsp = jj_scanpos;
5196     if (jj_3R_195()) jj_scanpos = xsp;
5197     else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5198     return false;
5199   }
5200
5201   static final private boolean jj_3R_127() {
5202     if (jj_scan_token(GT)) return true;
5203     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5204     return false;
5205   }
5206
5207   static final private boolean jj_3R_132() {
5208     if (jj_scan_token(LSHIFT)) return true;
5209     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5210     return false;
5211   }
5212
5213   static final private boolean jj_3R_125() {
5214     Token xsp;
5215     xsp = jj_scanpos;
5216     if (jj_3R_132()) {
5217     jj_scanpos = xsp;
5218     if (jj_3R_133()) {
5219     jj_scanpos = xsp;
5220     if (jj_3R_134()) return true;
5221     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5222     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5223     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5224     if (jj_3R_124()) return true;
5225     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5226     return false;
5227   }
5228
5229   static final private boolean jj_3R_117() {
5230     if (jj_3R_124()) return true;
5231     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5232     Token xsp;
5233     while (true) {
5234       xsp = jj_scanpos;
5235       if (jj_3R_125()) { jj_scanpos = xsp; break; }
5236       if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5237     }
5238     return false;
5239   }
5240
5241   static final private boolean jj_3R_110() {
5242     if (jj_3R_62()) return true;
5243     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5244     return false;
5245   }
5246
5247   static final private boolean jj_3R_43() {
5248     if (jj_scan_token(PHPEND)) return true;
5249     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5250     return false;
5251   }
5252
5253   static final private boolean jj_3R_126() {
5254     if (jj_scan_token(LT)) return true;
5255     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5256     return false;
5257   }
5258
5259   static final private boolean jj_3R_118() {
5260     Token xsp;
5261     xsp = jj_scanpos;
5262     if (jj_3R_126()) {
5263     jj_scanpos = xsp;
5264     if (jj_3R_127()) {
5265     jj_scanpos = xsp;
5266     if (jj_3R_128()) {
5267     jj_scanpos = xsp;
5268     if (jj_3R_129()) return true;
5269     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5270     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5271     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5272     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5273     if (jj_3R_117()) return true;
5274     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5275     return false;
5276   }
5277
5278   static final private boolean jj_3R_115() {
5279     if (jj_3R_117()) return true;
5280     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5281     Token xsp;
5282     while (true) {
5283       xsp = jj_scanpos;
5284       if (jj_3R_118()) { jj_scanpos = xsp; break; }
5285       if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5286     }
5287     return false;
5288   }
5289
5290   static final private boolean jj_3R_109() {
5291     if (jj_scan_token(LBRACE)) return true;
5292     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5293     if (jj_3R_41()) return true;
5294     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5295     if (jj_scan_token(RBRACE)) return true;
5296     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5297     return false;
5298   }
5299
5300   static final private boolean jj_3_6() {
5301     if (jj_3R_44()) return true;
5302     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5303     return false;
5304   }
5305
5306   static final private boolean jj_3R_42() {
5307     if (jj_scan_token(SEMICOLON)) return true;
5308     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5309     return false;
5310   }
5311
5312   static final private boolean jj_3R_73() {
5313     if (jj_scan_token(DOLLAR_ID)) return true;
5314     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5315     Token xsp;
5316     xsp = jj_scanpos;
5317     if (jj_3R_110()) jj_scanpos = xsp;
5318     else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5319     return false;
5320   }
5321
5322   static final private boolean jj_3_5() {
5323     if (jj_3R_41()) return true;
5324     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5325     Token xsp;
5326     xsp = jj_scanpos;
5327     if (jj_3R_42()) {
5328     jj_scanpos = xsp;
5329     if (jj_3R_43()) return true;
5330     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5331     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5332     return false;
5333   }
5334
5335   static final private boolean jj_3R_123() {
5336     if (jj_scan_token(TRIPLEEQUAL)) return true;
5337     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5338     return false;
5339   }
5340
5341   static final private boolean jj_3R_122() {
5342     if (jj_scan_token(BANGDOUBLEEQUAL)) return true;
5343     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5344     return false;
5345   }
5346
5347   static final private boolean jj_3R_72() {
5348     if (jj_scan_token(DOLLAR)) return true;
5349     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5350     if (jj_3R_62()) return true;
5351     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5352     return false;
5353   }
5354
5355   static final private boolean jj_3R_121() {
5356     if (jj_scan_token(NE)) return true;
5357     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5358     return false;
5359   }
5360
5361   static final private boolean jj_3R_120() {
5362     if (jj_scan_token(DIF)) return true;
5363     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5364     return false;
5365   }
5366
5367   static final private boolean jj_3R_119() {
5368     if (jj_scan_token(EQ)) return true;
5369     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5370     return false;
5371   }
5372
5373   static private boolean jj_initialized_once = false;
5374   static public PHPParserTokenManager token_source;
5375   static SimpleCharStream jj_input_stream;
5376   static public Token token, jj_nt;
5377   static private int jj_ntk;
5378   static private Token jj_scanpos, jj_lastpos;
5379   static private int jj_la;
5380   static public boolean lookingAhead = false;
5381   static private boolean jj_semLA;
5382   static private int jj_gen;
5383   static final private int[] jj_la1 = new int[122];
5384   static private int[] jj_la1_0;
5385   static private int[] jj_la1_1;
5386   static private int[] jj_la1_2;
5387   static private int[] jj_la1_3;
5388   static private int[] jj_la1_4;
5389   static {
5390       jj_la1_0();
5391       jj_la1_1();
5392       jj_la1_2();
5393       jj_la1_3();
5394       jj_la1_4();
5395    }
5396    private static void jj_la1_0() {
5397       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,0xf2400000,0xfe400000,0x0,0x0,0x0,0x0,0xe0000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xfe580000,0xfe580000,0xfa580000,0x0,0x0,0x0,0x0,0x2000000,0x0,0xfa580000,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,};
5398    }
5399    private static void jj_la1_1() {
5400       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,0x8ebaa47,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x8ebaa47,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,};
5401    }
5402    private static void jj_la1_2() {
5403       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,0x11445100,0x10000000,0x10000000,0x10000000,0x10000000,0x0,0x0,0x0,0x0,0x20000000,0x10000000,0x20000000,0x10000000,0x20000000,0x10000000,0x11445100,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,};
5404    }
5405    private static void jj_la1_3() {
5406       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,0x3c380000,0x0,0x0,0x0,0x0,0x0,0x100000,0x100000,0x100,0x0,0x0,0x0,0x0,0x0,0x0,0x3c380000,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,};
5407    }
5408    private static void jj_la1_4() {
5409       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,0x201,0x400,0x400,0x400,0x400,0x0,0x200,0x200,0x0,0x0,0x400,0x0,0x400,0x0,0x400,0x201,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,};
5410    }
5411   static final private JJCalls[] jj_2_rtns = new JJCalls[7];
5412   static private boolean jj_rescan = false;
5413   static private int jj_gc = 0;
5414
5415   public PHPParser(java.io.InputStream stream) {
5416     if (jj_initialized_once) {
5417       System.out.println("ERROR: Second call to constructor of static parser.  You must");
5418       System.out.println("       either use ReInit() or set the JavaCC option STATIC to false");
5419       System.out.println("       during parser generation.");
5420       throw new Error();
5421     }
5422     jj_initialized_once = true;
5423     jj_input_stream = new SimpleCharStream(stream, 1, 1);
5424     token_source = new PHPParserTokenManager(jj_input_stream);
5425     token = new Token();
5426     jj_ntk = -1;
5427     jj_gen = 0;
5428     for (int i = 0; i < 122; i++) jj_la1[i] = -1;
5429     for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
5430   }
5431
5432   static public void ReInit(java.io.InputStream stream) {
5433     jj_input_stream.ReInit(stream, 1, 1);
5434     token_source.ReInit(jj_input_stream);
5435     token = new Token();
5436     jj_ntk = -1;
5437     jj_gen = 0;
5438     for (int i = 0; i < 122; i++) jj_la1[i] = -1;
5439     for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
5440   }
5441
5442   public PHPParser(java.io.Reader stream) {
5443     if (jj_initialized_once) {
5444       System.out.println("ERROR: Second call to constructor of static parser.  You must");
5445       System.out.println("       either use ReInit() or set the JavaCC option STATIC to false");
5446       System.out.println("       during parser generation.");
5447       throw new Error();
5448     }
5449     jj_initialized_once = true;
5450     jj_input_stream = new SimpleCharStream(stream, 1, 1);
5451     token_source = new PHPParserTokenManager(jj_input_stream);
5452     token = new Token();
5453     jj_ntk = -1;
5454     jj_gen = 0;
5455     for (int i = 0; i < 122; i++) jj_la1[i] = -1;
5456     for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
5457   }
5458
5459   static public void ReInit(java.io.Reader stream) {
5460     jj_input_stream.ReInit(stream, 1, 1);
5461     token_source.ReInit(jj_input_stream);
5462     token = new Token();
5463     jj_ntk = -1;
5464     jj_gen = 0;
5465     for (int i = 0; i < 122; i++) jj_la1[i] = -1;
5466     for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
5467   }
5468
5469   public PHPParser(PHPParserTokenManager tm) {
5470     if (jj_initialized_once) {
5471       System.out.println("ERROR: Second call to constructor of static parser.  You must");
5472       System.out.println("       either use ReInit() or set the JavaCC option STATIC to false");
5473       System.out.println("       during parser generation.");
5474       throw new Error();
5475     }
5476     jj_initialized_once = true;
5477     token_source = tm;
5478     token = new Token();
5479     jj_ntk = -1;
5480     jj_gen = 0;
5481     for (int i = 0; i < 122; i++) jj_la1[i] = -1;
5482     for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
5483   }
5484
5485   public void ReInit(PHPParserTokenManager tm) {
5486     token_source = tm;
5487     token = new Token();
5488     jj_ntk = -1;
5489     jj_gen = 0;
5490     for (int i = 0; i < 122; i++) jj_la1[i] = -1;
5491     for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
5492   }
5493
5494   static final private Token jj_consume_token(int kind) throws ParseException {
5495     Token oldToken;
5496     if ((oldToken = token).next != null) token = token.next;
5497     else token = token.next = token_source.getNextToken();
5498     jj_ntk = -1;
5499     if (token.kind == kind) {
5500       jj_gen++;
5501       if (++jj_gc > 100) {
5502         jj_gc = 0;
5503         for (int i = 0; i < jj_2_rtns.length; i++) {
5504           JJCalls c = jj_2_rtns[i];
5505           while (c != null) {
5506             if (c.gen < jj_gen) c.first = null;
5507             c = c.next;
5508           }
5509         }
5510       }
5511       return token;
5512     }
5513     token = oldToken;
5514     jj_kind = kind;
5515     throw generateParseException();
5516   }
5517
5518   static final private boolean jj_scan_token(int kind) {
5519     if (jj_scanpos == jj_lastpos) {
5520       jj_la--;
5521       if (jj_scanpos.next == null) {
5522         jj_lastpos = jj_scanpos = jj_scanpos.next = token_source.getNextToken();
5523       } else {
5524         jj_lastpos = jj_scanpos = jj_scanpos.next;
5525       }
5526     } else {
5527       jj_scanpos = jj_scanpos.next;
5528     }
5529     if (jj_rescan) {
5530       int i = 0; Token tok = token;
5531       while (tok != null && tok != jj_scanpos) { i++; tok = tok.next; }
5532       if (tok != null) jj_add_error_token(kind, i);
5533     }
5534     return (jj_scanpos.kind != kind);
5535   }
5536
5537   static final public Token getNextToken() {
5538     if (token.next != null) token = token.next;
5539     else token = token.next = token_source.getNextToken();
5540     jj_ntk = -1;
5541     jj_gen++;
5542     return token;
5543   }
5544
5545   static final public Token getToken(int index) {
5546     Token t = lookingAhead ? jj_scanpos : token;
5547     for (int i = 0; i < index; i++) {
5548       if (t.next != null) t = t.next;
5549       else t = t.next = token_source.getNextToken();
5550     }
5551     return t;
5552   }
5553
5554   static final private int jj_ntk() {
5555     if ((jj_nt=token.next) == null)
5556       return (jj_ntk = (token.next=token_source.getNextToken()).kind);
5557     else
5558       return (jj_ntk = jj_nt.kind);
5559   }
5560
5561   static private java.util.Vector jj_expentries = new java.util.Vector();
5562   static private int[] jj_expentry;
5563   static private int jj_kind = -1;
5564   static private int[] jj_lasttokens = new int[100];
5565   static private int jj_endpos;
5566
5567   static private void jj_add_error_token(int kind, int pos) {
5568     if (pos >= 100) return;
5569     if (pos == jj_endpos + 1) {
5570       jj_lasttokens[jj_endpos++] = kind;
5571     } else if (jj_endpos != 0) {
5572       jj_expentry = new int[jj_endpos];
5573       for (int i = 0; i < jj_endpos; i++) {
5574         jj_expentry[i] = jj_lasttokens[i];
5575       }
5576       boolean exists = false;
5577       for (java.util.Enumeration enum = jj_expentries.elements(); enum.hasMoreElements();) {
5578         int[] oldentry = (int[])(enum.nextElement());
5579         if (oldentry.length == jj_expentry.length) {
5580           exists = true;
5581           for (int i = 0; i < jj_expentry.length; i++) {
5582             if (oldentry[i] != jj_expentry[i]) {
5583               exists = false;
5584               break;
5585             }
5586           }
5587           if (exists) break;
5588         }
5589       }
5590       if (!exists) jj_expentries.addElement(jj_expentry);
5591       if (pos != 0) jj_lasttokens[(jj_endpos = pos) - 1] = kind;
5592     }
5593   }
5594
5595   static public ParseException generateParseException() {
5596     jj_expentries.removeAllElements();
5597     boolean[] la1tokens = new boolean[139];
5598     for (int i = 0; i < 139; i++) {
5599       la1tokens[i] = false;
5600     }
5601     if (jj_kind >= 0) {
5602       la1tokens[jj_kind] = true;
5603       jj_kind = -1;
5604     }
5605     for (int i = 0; i < 122; i++) {
5606       if (jj_la1[i] == jj_gen) {
5607         for (int j = 0; j < 32; j++) {
5608           if ((jj_la1_0[i] & (1<<j)) != 0) {
5609             la1tokens[j] = true;
5610           }
5611           if ((jj_la1_1[i] & (1<<j)) != 0) {
5612             la1tokens[32+j] = true;
5613           }
5614           if ((jj_la1_2[i] & (1<<j)) != 0) {
5615             la1tokens[64+j] = true;
5616           }
5617           if ((jj_la1_3[i] & (1<<j)) != 0) {
5618             la1tokens[96+j] = true;
5619           }
5620           if ((jj_la1_4[i] & (1<<j)) != 0) {
5621             la1tokens[128+j] = true;
5622           }
5623         }
5624       }
5625     }
5626     for (int i = 0; i < 139; i++) {
5627       if (la1tokens[i]) {
5628         jj_expentry = new int[1];
5629         jj_expentry[0] = i;
5630         jj_expentries.addElement(jj_expentry);
5631       }
5632     }
5633     jj_endpos = 0;
5634     jj_rescan_token();
5635     jj_add_error_token(0, 0);
5636     int[][] exptokseq = new int[jj_expentries.size()][];
5637     for (int i = 0; i < jj_expentries.size(); i++) {
5638       exptokseq[i] = (int[])jj_expentries.elementAt(i);
5639     }
5640     return new ParseException(token, exptokseq, tokenImage);
5641   }
5642
5643   static final public void enable_tracing() {
5644   }
5645
5646   static final public void disable_tracing() {
5647   }
5648
5649   static final private void jj_rescan_token() {
5650     jj_rescan = true;
5651     for (int i = 0; i < 7; i++) {
5652       JJCalls p = jj_2_rtns[i];
5653       do {
5654         if (p.gen > jj_gen) {
5655           jj_la = p.arg; jj_lastpos = jj_scanpos = p.first;
5656           switch (i) {
5657             case 0: jj_3_1(); break;
5658             case 1: jj_3_2(); break;
5659             case 2: jj_3_3(); break;
5660             case 3: jj_3_4(); break;
5661             case 4: jj_3_5(); break;
5662             case 5: jj_3_6(); break;
5663             case 6: jj_3_7(); break;
5664           }
5665         }
5666         p = p.next;
5667       } while (p != null);
5668     }
5669     jj_rescan = false;
5670   }
5671
5672   static final private void jj_save(int index, int xla) {
5673     JJCalls p = jj_2_rtns[index];
5674     while (p.gen > jj_gen) {
5675       if (p.next == null) { p = p.next = new JJCalls(); break; }
5676       p = p.next;
5677     }
5678     p.gen = jj_gen + xla - jj_la; p.first = token; p.arg = xla;
5679   }
5680
5681   static final class JJCalls {
5682     int gen;
5683     Token first;
5684     int arg;
5685     JJCalls next;
5686   }
5687
5688 }