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