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