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