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