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