net.sourceforge.phpeclipse/src/test/PHPParser.java

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