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