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.ArrayList;
  12 import java.io.StringReader;
  13 import java.io.*;
  14 import java.text.MessageFormat;
  15
  16 import net.sourceforge.phpeclipse.actions.PHPStartApacheAction;
  17 import net.sourceforge.phpeclipse.PHPeclipsePlugin;
  18 import net.sourceforge.phpdt.internal.compiler.ast.*;
  19 import net.sourceforge.phpdt.internal.compiler.parser.OutlineableWithChildren;
  20 import net.sourceforge.phpdt.internal.compiler.parser.PHPOutlineInfo;
  21
  22 /**
  23  * A new php parser.
  24  * This php parser is inspired by the Java 1.2 grammar example
  25  * given with JavaCC. You can get JavaCC at http://www.webgain.com
  26  * You can test the parser with the PHPParserTestCase2.java
  27  * @author Matthieu Casanova
  28  */
  29 public final class PHPParser extends PHPParserSuperclass implements PHPParserConstants {
  30
  31   /** The file that is parsed. */
  32   private static IFile fileToParse;
  33
  34   /** The current segment. */
  35   private static OutlineableWithChildren currentSegment;
  36
  37   private static final String PARSE_ERROR_STRING = "Parse error"; //$NON-NLS-1$
  38   private static final String PARSE_WARNING_STRING = "Warning"; //$NON-NLS-1$
  39   static PHPOutlineInfo outlineInfo;
  40
  41   /** The error level of the current ParseException. */
  42   private static int errorLevel = ERROR;
  43   /** The message of the current ParseException. If it's null it's because the parse exception wasn't handled */
  44   private static String errorMessage;
  45
  46   private static int errorStart = -1;
  47   private static int errorEnd = -1;
  48   private static PHPDocument phpDocument;
  49
  50   private static final char[] SYNTAX_ERROR_CHAR = {'s','y','n','t','a','x',' ','e','r','r','o','r'};
  51   /**
  52    * The point where html starts.
  53    * It will be used by the token manager to create HTMLCode objects
  54    */
  55   public static int htmlStart;
  56
  57   //ast stack
  58   private final static int AstStackIncrement = 100;
  59   /** The stack of node. */
  60   private static AstNode[] nodes;
  61   /** The cursor in expression stack. */
  62   private static int nodePtr;
  63
  64   public final void setFileToParse(final IFile fileToParse) {
  65     this.fileToParse = fileToParse;
  66   }
  67
  68   public PHPParser() {
  69   }
  70
  71   public PHPParser(final IFile fileToParse) {
  72     this(new StringReader(""));
  73     this.fileToParse = fileToParse;
  74   }
  75
  76   /**
  77    * Reinitialize the parser.
  78    */
  79   private static final void init() {
  80     nodes = new AstNode[AstStackIncrement];
  81     nodePtr = -1;
  82     htmlStart = 0;
  83   }
  84
  85   /**
  86    * Add an php node on the stack.
  87    * @param node the node that will be added to the stack
  88    */
  89   private static final void pushOnAstNodes(AstNode node) {
  90     try {
  91       nodes[++nodePtr] = node;
  92     } catch (IndexOutOfBoundsException e) {
  93       int oldStackLength = nodes.length;
  94       AstNode[] oldStack = nodes;
  95       nodes = new AstNode[oldStackLength + AstStackIncrement];
  96       System.arraycopy(oldStack, 0, nodes, 0, oldStackLength);
  97       nodePtr = oldStackLength;
  98       nodes[nodePtr] = node;
  99     }
 100   }
 101
 102   public final PHPOutlineInfo parseInfo(final Object parent, final String s) {
 103     phpDocument = new PHPDocument(parent,"_root".toCharArray());
 104     currentSegment = phpDocument;
 105     outlineInfo = new PHPOutlineInfo(parent, currentSegment);
 106     final StringReader stream = new StringReader(s);
 107     if (jj_input_stream == null) {
 108       jj_input_stream = new SimpleCharStream(stream, 1, 1);
 109     }
 110     ReInit(stream);
 111     init();
 112     try {
 113       parse();
 114       phpDocument.nodes = new AstNode[nodes.length];
 115       System.arraycopy(nodes,0,phpDocument.nodes,0,nodes.length);
 116       if (PHPeclipsePlugin.DEBUG) {
 117         PHPeclipsePlugin.log(1,phpDocument.toString());
 118       }
 119     } catch (ParseException e) {
 120       processParseException(e);
 121     }
 122     return outlineInfo;
 123   }
 124
 125   /**
 126    * This method will process the parse exception.
 127    * If the error message is null, the parse exception wasn't catched and a trace is written in the log
 128    * @param e the ParseException
 129    */
 130   private static void processParseException(final ParseException e) {
 131     if (errorMessage == null) {
 132       PHPeclipsePlugin.log(e);
 133       errorMessage = "this exception wasn't handled by the parser please tell us how to reproduce it";
 134       errorStart = SimpleCharStream.getPosition();
 135       errorEnd   = errorStart + 1;
 136     }
 137     setMarker(e);
 138     errorMessage = null;
 139   }
 140
 141   /**
 142    * Create marker for the parse error
 143    * @param e the ParseException
 144    */
 145   private static void setMarker(final ParseException e) {
 146     try {
 147       if (errorStart == -1) {
 148         setMarker(fileToParse,
 149                   errorMessage,
 150                   SimpleCharStream.tokenBegin,
 151                   SimpleCharStream.tokenBegin + e.currentToken.image.length(),
 152                   errorLevel,
 153                   "Line " + e.currentToken.beginLine);
 154       } else {
 155         setMarker(fileToParse,
 156                   errorMessage,
 157                   errorStart,
 158                   errorEnd,
 159                   errorLevel,
 160                   "Line " + e.currentToken.beginLine);
 161         errorStart = -1;
 162         errorEnd = -1;
 163       }
 164     } catch (CoreException e2) {
 165       PHPeclipsePlugin.log(e2);
 166     }
 167   }
 168
 169   private static void scanLine(final String output,
 170                                final IFile file,
 171                                final int indx,
 172                                final int brIndx) throws CoreException {
 173     String current;
 174     StringBuffer lineNumberBuffer = new StringBuffer(10);
 175     char ch;
 176     current = output.substring(indx, brIndx);
 177
 178     if (current.indexOf(PARSE_WARNING_STRING) != -1 || current.indexOf(PARSE_ERROR_STRING) != -1) {
 179       int onLine = current.indexOf("on line <b>");
 180       if (onLine != -1) {
 181         lineNumberBuffer.delete(0, lineNumberBuffer.length());
 182         for (int i = onLine; i < current.length(); i++) {
 183           ch = current.charAt(i);
 184           if ('0' <= ch && '9' >= ch) {
 185             lineNumberBuffer.append(ch);
 186           }
 187         }
 188
 189         int lineNumber = Integer.parseInt(lineNumberBuffer.toString());
 190
 191         Hashtable attributes = new Hashtable();
 192
 193         current = current.replaceAll("\n", "");
 194         current = current.replaceAll("<b>", "");
 195         current = current.replaceAll("</b>", "");
 196         MarkerUtilities.setMessage(attributes, current);
 197
 198         if (current.indexOf(PARSE_ERROR_STRING) != -1)
 199           attributes.put(IMarker.SEVERITY, new Integer(IMarker.SEVERITY_ERROR));
 200         else if (current.indexOf(PARSE_WARNING_STRING) != -1)
 201           attributes.put(IMarker.SEVERITY, new Integer(IMarker.SEVERITY_WARNING));
 202         else
 203           attributes.put(IMarker.SEVERITY, new Integer(IMarker.SEVERITY_INFO));
 204         MarkerUtilities.setLineNumber(attributes, lineNumber);
 205         MarkerUtilities.createMarker(file, attributes, IMarker.PROBLEM);
 206       }
 207     }
 208   }
 209
 210   public final void parse(final String s) throws CoreException {
 211     final StringReader stream = new StringReader(s);
 212     if (jj_input_stream == null) {
 213       jj_input_stream = new SimpleCharStream(stream, 1, 1);
 214     }
 215     ReInit(stream);
 216     init();
 217     try {
 218       parse();
 219     } catch (ParseException e) {
 220       processParseException(e);
 221     }
 222   }
 223
 224   /**
 225    * Call the php parse command ( php -l -f &lt;filename&gt; )
 226    * and create markers according to the external parser output
 227    */
 228   public static void phpExternalParse(final IFile file) {
 229     final IPreferenceStore store = PHPeclipsePlugin.getDefault().getPreferenceStore();
 230     final String filename = file.getLocation().toString();
 231
 232     final String[] arguments = { filename };
 233     final MessageFormat form = new MessageFormat(store.getString(PHPeclipsePlugin.EXTERNAL_PARSER_PREF));
 234     final String command = form.format(arguments);
 235
 236     final String parserResult = PHPStartApacheAction.getParserOutput(command, "External parser: ");
 237
 238     try {
 239       // parse the buffer to find the errors and warnings
 240       createMarkers(parserResult, file);
 241     } catch (CoreException e) {
 242       PHPeclipsePlugin.log(e);
 243     }
 244   }
 245
 246   /**
 247    * Put a new html block in the stack.
 248    */
 249   public static final void createNewHTMLCode() {
 250     final int currentPosition = SimpleCharStream.getPosition();
 251     if (currentPosition == htmlStart) {
 252       return;
 253     }
 254     final char[] chars = SimpleCharStream.currentBuffer.substring(htmlStart,currentPosition+1).toCharArray();
 255     pushOnAstNodes(new HTMLCode(chars, htmlStart,currentPosition));
 256   }
 257
 258   /**
 259    * Create a new task.
 260    */
 261   public static final void createNewTask() {
 262     final int currentPosition = SimpleCharStream.getPosition();
 263     final String  todo = SimpleCharStream.currentBuffer.substring(currentPosition+1,
 264                                                                   SimpleCharStream.currentBuffer.indexOf("\n",
 265                                                                                                          currentPosition)-1);
 266     try {
 267       setMarker(fileToParse,
 268                 "todo : " + todo,
 269                 SimpleCharStream.getBeginLine(),
 270                 TASK,
 271                 "Line "+SimpleCharStream.getBeginLine());
 272     } catch (CoreException e) {
 273       PHPeclipsePlugin.log(e);
 274     }
 275   }
 276
 277   private static final void parse() throws ParseException {
 278           phpFile();
 279   }
 280
 281   static final public void phpFile() throws ParseException {
 282     try {
 283       label_1:
 284       while (true) {
 285         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
 286         case PHPSTARTSHORT:
 287         case PHPSTARTLONG:
 288         case PHPECHOSTART:
 289         case PHPEND:
 290         case CLASS:
 291         case FUNCTION:
 292         case IF:
 293         case ARRAY:
 294         case BREAK:
 295         case LIST:
 296         case PRINT:
 297         case ECHO:
 298         case INCLUDE:
 299         case REQUIRE:
 300         case INCLUDE_ONCE:
 301         case REQUIRE_ONCE:
 302         case GLOBAL:
 303         case STATIC:
 304         case CONTINUE:
 305         case DO:
 306         case FOR:
 307         case NEW:
 308         case NULL:
 309         case RETURN:
 310         case SWITCH:
 311         case TRUE:
 312         case FALSE:
 313         case WHILE:
 314         case FOREACH:
 315         case AT:
 316         case DOLLAR:
 317         case BANG:
 318         case INCR:
 319         case DECR:
 320         case PLUS:
 321         case MINUS:
 322         case BIT_AND:
 323         case INTEGER_LITERAL:
 324         case FLOATING_POINT_LITERAL:
 325         case STRING_LITERAL:
 326         case IDENTIFIER:
 327         case LPAREN:
 328         case LBRACE:
 329         case SEMICOLON:
 330         case DOLLAR_ID:
 331           ;
 332           break;
 333         default:
 334           jj_la1[0] = jj_gen;
 335           break label_1;
 336         }
 337         PhpBlock();
 338       }
 339      PHPParser.createNewHTMLCode();
 340     } catch (TokenMgrError e) {
 341     PHPeclipsePlugin.log(e);
 342     errorStart   = SimpleCharStream.getPosition();
 343     errorEnd     = errorStart + 1;
 344     errorMessage = e.getMessage();
 345     errorLevel   = ERROR;
 346     {if (true) throw generateParseException();}
 347     }
 348   }
 349
 350 /**
 351  * A php block is a <?= expression [;]?>
 352  * or <?php somephpcode ?>
 353  * or <? somephpcode ?>
 354  */
 355   static final public void PhpBlock() throws ParseException {
 356   final int start = SimpleCharStream.getPosition();
 357   final PHPEchoBlock phpEchoBlock;
 358     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
 359     case PHPECHOSTART:
 360       phpEchoBlock = phpEchoBlock();
 361    pushOnAstNodes(phpEchoBlock);
 362       break;
 363     case PHPSTARTSHORT:
 364     case PHPSTARTLONG:
 365     case PHPEND:
 366     case CLASS:
 367     case FUNCTION:
 368     case IF:
 369     case ARRAY:
 370     case BREAK:
 371     case LIST:
 372     case PRINT:
 373     case ECHO:
 374     case INCLUDE:
 375     case REQUIRE:
 376     case INCLUDE_ONCE:
 377     case REQUIRE_ONCE:
 378     case GLOBAL:
 379     case STATIC:
 380     case CONTINUE:
 381     case DO:
 382     case FOR:
 383     case NEW:
 384     case NULL:
 385     case RETURN:
 386     case SWITCH:
 387     case TRUE:
 388     case FALSE:
 389     case WHILE:
 390     case FOREACH:
 391     case AT:
 392     case DOLLAR:
 393     case BANG:
 394     case INCR:
 395     case DECR:
 396     case PLUS:
 397     case MINUS:
 398     case BIT_AND:
 399     case INTEGER_LITERAL:
 400     case FLOATING_POINT_LITERAL:
 401     case STRING_LITERAL:
 402     case IDENTIFIER:
 403     case LPAREN:
 404     case LBRACE:
 405     case SEMICOLON:
 406     case DOLLAR_ID:
 407       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
 408       case PHPSTARTSHORT:
 409       case PHPSTARTLONG:
 410         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
 411         case PHPSTARTLONG:
 412           jj_consume_token(PHPSTARTLONG);
 413           break;
 414         case PHPSTARTSHORT:
 415           jj_consume_token(PHPSTARTSHORT);
 416      try {
 417       setMarker(fileToParse,
 418                 "You should use '<?php' instead of '<?' it will avoid some problems with XML",
 419                 start,
 420                 SimpleCharStream.getPosition(),
 421                 INFO,
 422                 "Line " + token.beginLine);
 423     } catch (CoreException e) {
 424       PHPeclipsePlugin.log(e);
 425     }
 426           break;
 427         default:
 428           jj_la1[1] = jj_gen;
 429           jj_consume_token(-1);
 430           throw new ParseException();
 431         }
 432         break;
 433       default:
 434         jj_la1[2] = jj_gen;
 435         ;
 436       }
 437       Php();
 438       try {
 439         jj_consume_token(PHPEND);
 440       } catch (ParseException e) {
 441     errorMessage = "'?>' expected";
 442     errorLevel   = ERROR;
 443     errorStart = SimpleCharStream.getPosition() - e.currentToken.next.image.length() + 1;
 444     errorEnd   = SimpleCharStream.getPosition() + 1;
 445     processParseException(e);
 446       }
 447       break;
 448     default:
 449       jj_la1[3] = jj_gen;
 450       jj_consume_token(-1);
 451       throw new ParseException();
 452     }
 453   }
 454
 455   static final public PHPEchoBlock phpEchoBlock() throws ParseException {
 456   final Expression expr;
 457   final int pos = SimpleCharStream.getPosition();
 458   PHPEchoBlock echoBlock;
 459     jj_consume_token(PHPECHOSTART);
 460     expr = Expression();
 461     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
 462     case SEMICOLON:
 463       jj_consume_token(SEMICOLON);
 464       break;
 465     default:
 466       jj_la1[4] = jj_gen;
 467       ;
 468     }
 469     jj_consume_token(PHPEND);
 470   echoBlock = new PHPEchoBlock(expr,pos,SimpleCharStream.getPosition());
 471   pushOnAstNodes(echoBlock);
 472   {if (true) return echoBlock;}
 473     throw new Error("Missing return statement in function");
 474   }
 475
 476   static final public void Php() throws ParseException {
 477     label_2:
 478     while (true) {
 479       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
 480       case CLASS:
 481       case FUNCTION:
 482       case IF:
 483       case ARRAY:
 484       case BREAK:
 485       case LIST:
 486       case PRINT:
 487       case ECHO:
 488       case INCLUDE:
 489       case REQUIRE:
 490       case INCLUDE_ONCE:
 491       case REQUIRE_ONCE:
 492       case GLOBAL:
 493       case STATIC:
 494       case CONTINUE:
 495       case DO:
 496       case FOR:
 497       case NEW:
 498       case NULL:
 499       case RETURN:
 500       case SWITCH:
 501       case TRUE:
 502       case FALSE:
 503       case WHILE:
 504       case FOREACH:
 505       case AT:
 506       case DOLLAR:
 507       case BANG:
 508       case INCR:
 509       case DECR:
 510       case PLUS:
 511       case MINUS:
 512       case BIT_AND:
 513       case INTEGER_LITERAL:
 514       case FLOATING_POINT_LITERAL:
 515       case STRING_LITERAL:
 516       case IDENTIFIER:
 517       case LPAREN:
 518       case LBRACE:
 519       case SEMICOLON:
 520       case DOLLAR_ID:
 521         ;
 522         break;
 523       default:
 524         jj_la1[5] = jj_gen;
 525         break label_2;
 526       }
 527       BlockStatement();
 528     }
 529   }
 530
 531   static final public ClassDeclaration ClassDeclaration() throws ParseException {
 532   final ClassDeclaration classDeclaration;
 533   final Token className;
 534   Token superclassName = null;
 535   final int pos;
 536   char[] classNameImage = SYNTAX_ERROR_CHAR;
 537   char[] superclassNameImage = null;
 538     jj_consume_token(CLASS);
 539    pos = SimpleCharStream.getPosition();
 540     try {
 541       className = jj_consume_token(IDENTIFIER);
 542      classNameImage = className.image.toCharArray();
 543     } catch (ParseException e) {
 544     errorMessage = "unexpected token : '"+ e.currentToken.next.image +"', identifier expected";
 545     errorLevel   = ERROR;
 546     errorStart   = SimpleCharStream.getPosition() - e.currentToken.next.image.length() + 1;
 547     errorEnd     = SimpleCharStream.getPosition() + 1;
 548     processParseException(e);
 549     }
 550     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
 551     case EXTENDS:
 552       jj_consume_token(EXTENDS);
 553       try {
 554         superclassName = jj_consume_token(IDENTIFIER);
 555        superclassNameImage = superclassName.image.toCharArray();
 556       } catch (ParseException e) {
 557       errorMessage = "unexpected token : '"+ e.currentToken.next.image +"', identifier expected";
 558       errorLevel   = ERROR;
 559       errorStart = SimpleCharStream.getPosition() - e.currentToken.next.image.length() + 1;
 560       errorEnd   = SimpleCharStream.getPosition() + 1;
 561       processParseException(e);
 562       superclassNameImage = SYNTAX_ERROR_CHAR;
 563       }
 564       break;
 565     default:
 566       jj_la1[6] = jj_gen;
 567       ;
 568     }
 569     if (superclassNameImage == null) {
 570       classDeclaration = new ClassDeclaration(currentSegment,
 571                                               classNameImage,
 572                                               pos,
 573                                               0);
 574     } else {
 575       classDeclaration = new ClassDeclaration(currentSegment,
 576                                               classNameImage,
 577                                               superclassNameImage,
 578                                               pos,
 579                                               0);
 580     }
 581       currentSegment.add(classDeclaration);
 582       currentSegment = classDeclaration;
 583     ClassBody(classDeclaration);
 584    currentSegment = (OutlineableWithChildren) currentSegment.getParent();
 585    classDeclaration.sourceEnd = SimpleCharStream.getPosition();
 586    pushOnAstNodes(classDeclaration);
 587    {if (true) return classDeclaration;}
 588     throw new Error("Missing return statement in function");
 589   }
 590
 591   static final public void ClassBody(ClassDeclaration classDeclaration) throws ParseException {
 592     try {
 593       jj_consume_token(LBRACE);
 594     } catch (ParseException e) {
 595     errorMessage = "unexpected token : '"+ e.currentToken.next.image + "', '{' expected";
 596     errorLevel   = ERROR;
 597     errorStart = SimpleCharStream.getPosition() - e.currentToken.next.image.length() + 1;
 598     errorEnd   = SimpleCharStream.getPosition() + 1;
 599     {if (true) throw e;}
 600     }
 601     label_3:
 602     while (true) {
 603       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
 604       case FUNCTION:
 605       case VAR:
 606         ;
 607         break;
 608       default:
 609         jj_la1[7] = jj_gen;
 610         break label_3;
 611       }
 612       ClassBodyDeclaration(classDeclaration);
 613     }
 614     try {
 615       jj_consume_token(RBRACE);
 616     } catch (ParseException e) {
 617     errorMessage = "unexpected token : '"+ e.currentToken.next.image +"', 'var', 'function' or '}' expected";
 618     errorLevel   = ERROR;
 619     errorStart = SimpleCharStream.getPosition() - e.currentToken.next.image.length() + 1;
 620     errorEnd   = SimpleCharStream.getPosition() + 1;
 621     {if (true) throw e;}
 622     }
 623   }
 624
 625 /**
 626  * A class can contain only methods and fields.
 627  */
 628   static final public void ClassBodyDeclaration(ClassDeclaration classDeclaration) throws ParseException {
 629   MethodDeclaration method;
 630   FieldDeclaration field;
 631     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
 632     case FUNCTION:
 633       method = MethodDeclaration();
 634                                 classDeclaration.addMethod(method);
 635       break;
 636     case VAR:
 637       field = FieldDeclaration();
 638                                 classDeclaration.addField(field);
 639       break;
 640     default:
 641       jj_la1[8] = jj_gen;
 642       jj_consume_token(-1);
 643       throw new ParseException();
 644     }
 645   }
 646
 647 /**
 648  * A class field declaration : it's var VariableDeclarator() (, VariableDeclarator())*;.
 649  */
 650   static final public FieldDeclaration FieldDeclaration() throws ParseException {
 651   VariableDeclaration variableDeclaration;
 652   VariableDeclaration[] list;
 653   final ArrayList arrayList = new ArrayList();
 654   final int pos = SimpleCharStream.getPosition();
 655     jj_consume_token(VAR);
 656     variableDeclaration = VariableDeclarator();
 657    arrayList.add(variableDeclaration);
 658    outlineInfo.addVariable(new String(variableDeclaration.name));
 659     label_4:
 660     while (true) {
 661       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
 662       case COMMA:
 663         ;
 664         break;
 665       default:
 666         jj_la1[9] = jj_gen;
 667         break label_4;
 668       }
 669       jj_consume_token(COMMA);
 670       variableDeclaration = VariableDeclarator();
 671        arrayList.add(variableDeclaration);
 672        outlineInfo.addVariable(new String(variableDeclaration.name));
 673     }
 674     try {
 675       jj_consume_token(SEMICOLON);
 676     } catch (ParseException e) {
 677     errorMessage = "unexpected token : '"+ e.currentToken.next.image +"'. A ';' was expected after variable declaration";
 678     errorLevel   = ERROR;
 679     errorStart   = SimpleCharStream.getPosition() - e.currentToken.next.image.length() + 1;
 680     errorEnd     = SimpleCharStream.getPosition() + 1;
 681     processParseException(e);
 682     }
 683    list = new VariableDeclaration[arrayList.size()];
 684    arrayList.toArray(list);
 685    {if (true) return new FieldDeclaration(list,
 686                                pos,
 687                                SimpleCharStream.getPosition(),
 688                                currentSegment);}
 689     throw new Error("Missing return statement in function");
 690   }
 691
 692   static final public VariableDeclaration VariableDeclarator() throws ParseException {
 693   final String varName;
 694   Expression initializer = null;
 695   final int pos = SimpleCharStream.getPosition();
 696     varName = VariableDeclaratorId();
 697     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
 698     case ASSIGN:
 699       jj_consume_token(ASSIGN);
 700       try {
 701         initializer = VariableInitializer();
 702       } catch (ParseException e) {
 703       errorMessage = "Literal expression expected in variable initializer";
 704       errorLevel   = ERROR;
 705       errorStart = SimpleCharStream.getPosition() - e.currentToken.next.image.length() + 1;
 706       errorEnd   = SimpleCharStream.getPosition() + 1;
 707       {if (true) throw e;}
 708       }
 709       break;
 710     default:
 711       jj_la1[10] = jj_gen;
 712       ;
 713     }
 714   if (initializer == null) {
 715     {if (true) return new VariableDeclaration(currentSegment,
 716                                   varName.toCharArray(),
 717                                   pos,
 718                                   SimpleCharStream.getPosition());}
 719   }
 720     {if (true) return new VariableDeclaration(currentSegment,
 721                                     varName.toCharArray(),
 722                                     initializer,
 723                                     pos);}
 724     throw new Error("Missing return statement in function");
 725   }
 726
 727 /**
 728  * A Variable name.
 729  * @return the variable name (with suffix)
 730  */
 731   static final public String VariableDeclaratorId() throws ParseException {
 732   String expr;
 733   Expression expression = null;
 734   final StringBuffer buff = new StringBuffer();
 735   final int pos = SimpleCharStream.getPosition();
 736   ConstantIdentifier ex;
 737     try {
 738       expr = Variable();
 739       label_5:
 740       while (true) {
 741         if (jj_2_1(2)) {
 742           ;
 743         } else {
 744           break label_5;
 745         }
 746        ex = new ConstantIdentifier(expr.toCharArray(),
 747                                    pos,
 748                                    SimpleCharStream.getPosition());
 749         expression = VariableSuffix(ex);
 750       }
 751      if (expression == null) {
 752        {if (true) return expr;}
 753      }
 754      {if (true) return expression.toStringExpression();}
 755     } catch (ParseException e) {
 756     errorMessage = "'$' expected for variable identifier";
 757     errorLevel   = ERROR;
 758     errorStart = SimpleCharStream.getPosition() - e.currentToken.next.image.length() + 1;
 759     errorEnd   = SimpleCharStream.getPosition() + 1;
 760     {if (true) throw e;}
 761     }
 762     throw new Error("Missing return statement in function");
 763   }
 764
 765 /**
 766  * Return a variablename without the $.
 767  * @return a variable name
 768  */
 769   static final public String Variable() throws ParseException {
 770   final StringBuffer buff;
 771   Expression expression = null;
 772   final Token token;
 773   final String expr;
 774     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
 775     case DOLLAR_ID:
 776       token = jj_consume_token(DOLLAR_ID);
 777       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
 778       case LBRACE:
 779         jj_consume_token(LBRACE);
 780         expression = Expression();
 781         jj_consume_token(RBRACE);
 782         break;
 783       default:
 784         jj_la1[11] = jj_gen;
 785         ;
 786       }
 787     if (expression == null) {
 788       {if (true) return token.image.substring(1);}
 789     }
 790     buff = new StringBuffer(token.image);
 791     buff.append("{");
 792     buff.append(expression.toStringExpression());
 793     buff.append("}");
 794     {if (true) return buff.toString();}
 795       break;
 796     case DOLLAR:
 797       jj_consume_token(DOLLAR);
 798       expr = VariableName();
 799    {if (true) return expr;}
 800       break;
 801     default:
 802       jj_la1[12] = jj_gen;
 803       jj_consume_token(-1);
 804       throw new ParseException();
 805     }
 806     throw new Error("Missing return statement in function");
 807   }
 808
 809 /**
 810  * A Variable name (without the $)
 811  * @return a variable name String
 812  */
 813   static final public String VariableName() throws ParseException {
 814   final StringBuffer buff;
 815   String expr = null;
 816   Expression expression = null;
 817   final Token token;
 818     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
 819     case LBRACE:
 820       jj_consume_token(LBRACE);
 821       expression = Expression();
 822       jj_consume_token(RBRACE);
 823    buff = new StringBuffer("{");
 824    buff.append(expression.toStringExpression());
 825    buff.append("}");
 826    {if (true) return buff.toString();}
 827       break;
 828     case IDENTIFIER:
 829       token = jj_consume_token(IDENTIFIER);
 830       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
 831       case LBRACE:
 832         jj_consume_token(LBRACE);
 833         expression = Expression();
 834         jj_consume_token(RBRACE);
 835         break;
 836       default:
 837         jj_la1[13] = jj_gen;
 838         ;
 839       }
 840     if (expression == null) {
 841       {if (true) return token.image;}
 842     }
 843     buff = new StringBuffer(token.image);
 844     buff.append("{");
 845     buff.append(expression.toStringExpression());
 846     buff.append("}");
 847     {if (true) return buff.toString();}
 848       break;
 849     case DOLLAR:
 850       jj_consume_token(DOLLAR);
 851       expr = VariableName();
 852     buff = new StringBuffer("$");
 853     buff.append(expr);
 854     {if (true) return buff.toString();}
 855       break;
 856     case DOLLAR_ID:
 857       token = jj_consume_token(DOLLAR_ID);
 858                        {if (true) return token.image;}
 859       break;
 860     default:
 861       jj_la1[14] = jj_gen;
 862       jj_consume_token(-1);
 863       throw new ParseException();
 864     }
 865     throw new Error("Missing return statement in function");
 866   }
 867
 868   static final public Expression VariableInitializer() throws ParseException {
 869   final Expression expr;
 870   final Token token;
 871   final int pos = SimpleCharStream.getPosition();
 872     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
 873     case NULL:
 874     case TRUE:
 875     case FALSE:
 876     case INTEGER_LITERAL:
 877     case FLOATING_POINT_LITERAL:
 878     case STRING_LITERAL:
 879       expr = Literal();
 880    {if (true) return expr;}
 881       break;
 882     case MINUS:
 883       jj_consume_token(MINUS);
 884       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
 885       case INTEGER_LITERAL:
 886         token = jj_consume_token(INTEGER_LITERAL);
 887         break;
 888       case FLOATING_POINT_LITERAL:
 889         token = jj_consume_token(FLOATING_POINT_LITERAL);
 890         break;
 891       default:
 892         jj_la1[15] = jj_gen;
 893         jj_consume_token(-1);
 894         throw new ParseException();
 895       }
 896    {if (true) return new PrefixedUnaryExpression(new NumberLiteral(token.image.toCharArray(),
 897                                                         pos,
 898                                                         SimpleCharStream.getPosition()),
 899                                       OperatorIds.MINUS,
 900                                       pos);}
 901       break;
 902     case PLUS:
 903       jj_consume_token(PLUS);
 904       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
 905       case INTEGER_LITERAL:
 906         token = jj_consume_token(INTEGER_LITERAL);
 907         break;
 908       case FLOATING_POINT_LITERAL:
 909         token = jj_consume_token(FLOATING_POINT_LITERAL);
 910         break;
 911       default:
 912         jj_la1[16] = jj_gen;
 913         jj_consume_token(-1);
 914         throw new ParseException();
 915       }
 916    {if (true) return new PrefixedUnaryExpression(new NumberLiteral(token.image.toCharArray(),
 917                                                         pos,
 918                                                         SimpleCharStream.getPosition()),
 919                                       OperatorIds.PLUS,
 920                                       pos);}
 921       break;
 922     case ARRAY:
 923       expr = ArrayDeclarator();
 924    {if (true) return expr;}
 925       break;
 926     case IDENTIFIER:
 927       token = jj_consume_token(IDENTIFIER);
 928    {if (true) return new ConstantIdentifier(token.image.toCharArray(),pos,SimpleCharStream.getPosition());}
 929       break;
 930     default:
 931       jj_la1[17] = jj_gen;
 932       jj_consume_token(-1);
 933       throw new ParseException();
 934     }
 935     throw new Error("Missing return statement in function");
 936   }
 937
 938   static final public ArrayVariableDeclaration ArrayVariable() throws ParseException {
 939 Expression expr,expr2;
 940     expr = Expression();
 941     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
 942     case ARRAYASSIGN:
 943       jj_consume_token(ARRAYASSIGN);
 944       expr2 = Expression();
 945    {if (true) return new ArrayVariableDeclaration(expr,expr2);}
 946       break;
 947     default:
 948       jj_la1[18] = jj_gen;
 949       ;
 950     }
 951    {if (true) return new ArrayVariableDeclaration(expr,SimpleCharStream.getPosition());}
 952     throw new Error("Missing return statement in function");
 953   }
 954
 955   static final public ArrayVariableDeclaration[] ArrayInitializer() throws ParseException {
 956   ArrayVariableDeclaration expr;
 957   final ArrayList list = new ArrayList();
 958     jj_consume_token(LPAREN);
 959     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
 960     case ARRAY:
 961     case LIST:
 962     case PRINT:
 963     case NEW:
 964     case NULL:
 965     case TRUE:
 966     case FALSE:
 967     case AT:
 968     case DOLLAR:
 969     case BANG:
 970     case INCR:
 971     case DECR:
 972     case PLUS:
 973     case MINUS:
 974     case BIT_AND:
 975     case INTEGER_LITERAL:
 976     case FLOATING_POINT_LITERAL:
 977     case STRING_LITERAL:
 978     case IDENTIFIER:
 979     case LPAREN:
 980     case DOLLAR_ID:
 981       expr = ArrayVariable();
 982              list.add(expr);
 983       label_6:
 984       while (true) {
 985         if (jj_2_2(2)) {
 986           ;
 987         } else {
 988           break label_6;
 989         }
 990         jj_consume_token(COMMA);
 991         expr = ArrayVariable();
 992              list.add(expr);
 993       }
 994       break;
 995     default:
 996       jj_la1[19] = jj_gen;
 997       ;
 998     }
 999     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1000     case COMMA:
1001       jj_consume_token(COMMA);
1002                      list.add(null);
1003       break;
1004     default:
1005       jj_la1[20] = jj_gen;
1006       ;
1007     }
1008     jj_consume_token(RPAREN);
1009   ArrayVariableDeclaration[] vars = new ArrayVariableDeclaration[list.size()];
1010   list.toArray(vars);
1011   {if (true) return vars;}
1012     throw new Error("Missing return statement in function");
1013   }
1014
1015 /**
1016  * A Method Declaration.
1017  * <b>function</b> MetodDeclarator() Block()
1018  */
1019   static final public MethodDeclaration MethodDeclaration() throws ParseException {
1020   final MethodDeclaration functionDeclaration;
1021   final Block block;
1022   final OutlineableWithChildren seg = currentSegment;
1023     jj_consume_token(FUNCTION);
1024     try {
1025       functionDeclaration = MethodDeclarator();
1026      outlineInfo.addVariable(new String(functionDeclaration.name));
1027     } catch (ParseException e) {
1028     if (errorMessage != null)  {if (true) throw e;}
1029     errorMessage = "unexpected token : '"+ e.currentToken.next.image +"', function identifier expected";
1030     errorLevel   = ERROR;
1031     errorStart = SimpleCharStream.getPosition() - e.currentToken.next.image.length() + 1;
1032     errorEnd   = SimpleCharStream.getPosition() + 1;
1033     {if (true) throw e;}
1034     }
1035    currentSegment = functionDeclaration;
1036     block = Block();
1037    functionDeclaration.statements = block.statements;
1038    currentSegment = seg;
1039    {if (true) return functionDeclaration;}
1040     throw new Error("Missing return statement in function");
1041   }
1042
1043 /**
1044  * A MethodDeclarator.
1045  * [&] IDENTIFIER(parameters ...).
1046  * @return a function description for the outline
1047  */
1048   static final public MethodDeclaration MethodDeclarator() throws ParseException {
1049   final Token identifier;
1050   Token reference = null;
1051   final Hashtable formalParameters;
1052   final int pos = SimpleCharStream.getPosition();
1053   char[] identifierChar = SYNTAX_ERROR_CHAR;
1054     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1055     case BIT_AND:
1056       reference = jj_consume_token(BIT_AND);
1057       break;
1058     default:
1059       jj_la1[21] = jj_gen;
1060       ;
1061     }
1062     try {
1063       identifier = jj_consume_token(IDENTIFIER);
1064      identifierChar = identifier.image.toCharArray();
1065     } catch (ParseException e) {
1066     errorMessage = "unexpected token : '"+ e.currentToken.next.image +"', function identifier expected";
1067     errorLevel   = ERROR;
1068     errorStart = SimpleCharStream.getPosition() - e.currentToken.next.image.length() + 1;
1069     errorEnd   = SimpleCharStream.getPosition() + 1;
1070     processParseException(e);
1071     }
1072     formalParameters = FormalParameters();
1073    {if (true) return new MethodDeclaration(currentSegment,
1074                                 identifierChar,
1075                                 formalParameters,
1076                                 reference != null,
1077                                 pos,
1078                                 SimpleCharStream.getPosition());}
1079     throw new Error("Missing return statement in function");
1080   }
1081
1082 /**
1083  * FormalParameters follows method identifier.
1084  * (FormalParameter())
1085  */
1086   static final public Hashtable FormalParameters() throws ParseException {
1087   VariableDeclaration var;
1088   final Hashtable parameters = new Hashtable();
1089     try {
1090       jj_consume_token(LPAREN);
1091     } catch (ParseException e) {
1092     errorMessage = "unexpected token : '"+ e.currentToken.next.image +"', '(' expected after function identifier";
1093     errorLevel   = ERROR;
1094     errorStart = SimpleCharStream.getPosition() - e.currentToken.next.image.length() + 1;
1095     errorEnd   = SimpleCharStream.getPosition() + 1;
1096     processParseException(e);
1097     }
1098     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1099     case DOLLAR:
1100     case BIT_AND:
1101     case DOLLAR_ID:
1102       var = FormalParameter();
1103                parameters.put(new String(var.name),var);
1104       label_7:
1105       while (true) {
1106         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1107         case COMMA:
1108           ;
1109           break;
1110         default:
1111           jj_la1[22] = jj_gen;
1112           break label_7;
1113         }
1114         jj_consume_token(COMMA);
1115         var = FormalParameter();
1116                  parameters.put(new String(var.name),var);
1117       }
1118       break;
1119     default:
1120       jj_la1[23] = jj_gen;
1121       ;
1122     }
1123     try {
1124       jj_consume_token(RPAREN);
1125     } catch (ParseException e) {
1126     errorMessage = "')' expected";
1127     errorLevel   = ERROR;
1128     errorStart = SimpleCharStream.getPosition() - e.currentToken.next.image.length() + 1;
1129     errorEnd   = SimpleCharStream.getPosition() + 1;
1130     processParseException(e);
1131     }
1132   {if (true) return parameters;}
1133     throw new Error("Missing return statement in function");
1134   }
1135
1136 /**
1137  * A formal parameter.
1138  * $varname[=value] (,$varname[=value])
1139  */
1140   static final public VariableDeclaration FormalParameter() throws ParseException {
1141   final VariableDeclaration variableDeclaration;
1142   Token token = null;
1143     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1144     case BIT_AND:
1145       token = jj_consume_token(BIT_AND);
1146       break;
1147     default:
1148       jj_la1[24] = jj_gen;
1149       ;
1150     }
1151     variableDeclaration = VariableDeclarator();
1152     if (token != null) {
1153       variableDeclaration.setReference(true);
1154     }
1155     {if (true) return variableDeclaration;}
1156     throw new Error("Missing return statement in function");
1157   }
1158
1159   static final public ConstantIdentifier Type() throws ParseException {
1160  final int pos;
1161     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1162     case STRING:
1163       jj_consume_token(STRING);
1164                         pos = SimpleCharStream.getPosition();
1165                         {if (true) return new ConstantIdentifier(Types.STRING,pos,pos-6);}
1166       break;
1167     case BOOL:
1168       jj_consume_token(BOOL);
1169                         pos = SimpleCharStream.getPosition();
1170                         {if (true) return new ConstantIdentifier(Types.BOOL,pos,pos-4);}
1171       break;
1172     case BOOLEAN:
1173       jj_consume_token(BOOLEAN);
1174                         pos = SimpleCharStream.getPosition();
1175                         {if (true) return new ConstantIdentifier(Types.BOOLEAN,pos,pos-7);}
1176       break;
1177     case REAL:
1178       jj_consume_token(REAL);
1179                         pos = SimpleCharStream.getPosition();
1180                         {if (true) return new ConstantIdentifier(Types.REAL,pos,pos-4);}
1181       break;
1182     case DOUBLE:
1183       jj_consume_token(DOUBLE);
1184                         pos = SimpleCharStream.getPosition();
1185                         {if (true) return new ConstantIdentifier(Types.DOUBLE,pos,pos-5);}
1186       break;
1187     case FLOAT:
1188       jj_consume_token(FLOAT);
1189                         pos = SimpleCharStream.getPosition();
1190                         {if (true) return new ConstantIdentifier(Types.FLOAT,pos,pos-5);}
1191       break;
1192     case INT:
1193       jj_consume_token(INT);
1194                         pos = SimpleCharStream.getPosition();
1195                         {if (true) return new ConstantIdentifier(Types.INT,pos,pos-3);}
1196       break;
1197     case INTEGER:
1198       jj_consume_token(INTEGER);
1199                         pos = SimpleCharStream.getPosition();
1200                         {if (true) return new ConstantIdentifier(Types.INTEGER,pos,pos-7);}
1201       break;
1202     case OBJECT:
1203       jj_consume_token(OBJECT);
1204                         pos = SimpleCharStream.getPosition();
1205                         {if (true) return new ConstantIdentifier(Types.OBJECT,pos,pos-6);}
1206       break;
1207     default:
1208       jj_la1[25] = jj_gen;
1209       jj_consume_token(-1);
1210       throw new ParseException();
1211     }
1212     throw new Error("Missing return statement in function");
1213   }
1214
1215   static final public Expression Expression() throws ParseException {
1216   final Expression expr;
1217     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1218     case PRINT:
1219       expr = PrintExpression();
1220                                   {if (true) return expr;}
1221       break;
1222     case LIST:
1223       expr = ListExpression();
1224                                   {if (true) return expr;}
1225       break;
1226     default:
1227       jj_la1[26] = jj_gen;
1228       if (jj_2_3(2147483647)) {
1229         expr = varAssignation();
1230                                   {if (true) return expr;}
1231       } else {
1232         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1233         case ARRAY:
1234         case NEW:
1235         case NULL:
1236         case TRUE:
1237         case FALSE:
1238         case AT:
1239         case DOLLAR:
1240         case BANG:
1241         case INCR:
1242         case DECR:
1243         case PLUS:
1244         case MINUS:
1245         case BIT_AND:
1246         case INTEGER_LITERAL:
1247         case FLOATING_POINT_LITERAL:
1248         case STRING_LITERAL:
1249         case IDENTIFIER:
1250         case LPAREN:
1251         case DOLLAR_ID:
1252           expr = ConditionalExpression();
1253                                   {if (true) return expr;}
1254           break;
1255         default:
1256           jj_la1[27] = jj_gen;
1257           jj_consume_token(-1);
1258           throw new ParseException();
1259         }
1260       }
1261     }
1262     throw new Error("Missing return statement in function");
1263   }
1264
1265 /**
1266  * A Variable assignation.
1267  * varName (an assign operator) any expression
1268  */
1269   static final public VarAssignation varAssignation() throws ParseException {
1270   String varName;
1271   final Expression initializer;
1272   final int assignOperator;
1273   final int pos = SimpleCharStream.getPosition();
1274     varName = VariableDeclaratorId();
1275     assignOperator = AssignmentOperator();
1276     try {
1277       initializer = Expression();
1278     } catch (ParseException e) {
1279       if (errorMessage != null) {
1280         {if (true) throw e;}
1281       }
1282       errorMessage = "expression expected";
1283       errorLevel   = ERROR;
1284       errorStart = SimpleCharStream.getPosition() - e.currentToken.next.image.length() + 1;
1285       errorEnd   = SimpleCharStream.getPosition() + 1;
1286       {if (true) throw e;}
1287     }
1288      {if (true) return new VarAssignation(varName.toCharArray(),
1289                                initializer,
1290                                assignOperator,
1291                                pos,
1292                                SimpleCharStream.getPosition());}
1293     throw new Error("Missing return statement in function");
1294   }
1295
1296   static final public int AssignmentOperator() throws ParseException {
1297     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1298     case ASSIGN:
1299       jj_consume_token(ASSIGN);
1300                         {if (true) return VarAssignation.EQUAL;}
1301       break;
1302     case STARASSIGN:
1303       jj_consume_token(STARASSIGN);
1304                         {if (true) return VarAssignation.STAR_EQUAL;}
1305       break;
1306     case SLASHASSIGN:
1307       jj_consume_token(SLASHASSIGN);
1308                         {if (true) return VarAssignation.SLASH_EQUAL;}
1309       break;
1310     case REMASSIGN:
1311       jj_consume_token(REMASSIGN);
1312                         {if (true) return VarAssignation.REM_EQUAL;}
1313       break;
1314     case PLUSASSIGN:
1315       jj_consume_token(PLUSASSIGN);
1316                         {if (true) return VarAssignation.PLUS_EQUAL;}
1317       break;
1318     case MINUSASSIGN:
1319       jj_consume_token(MINUSASSIGN);
1320                         {if (true) return VarAssignation.MINUS_EQUAL;}
1321       break;
1322     case LSHIFTASSIGN:
1323       jj_consume_token(LSHIFTASSIGN);
1324                         {if (true) return VarAssignation.LSHIFT_EQUAL;}
1325       break;
1326     case RSIGNEDSHIFTASSIGN:
1327       jj_consume_token(RSIGNEDSHIFTASSIGN);
1328                         {if (true) return VarAssignation.RSIGNEDSHIFT_EQUAL;}
1329       break;
1330     case ANDASSIGN:
1331       jj_consume_token(ANDASSIGN);
1332                         {if (true) return VarAssignation.AND_EQUAL;}
1333       break;
1334     case XORASSIGN:
1335       jj_consume_token(XORASSIGN);
1336                         {if (true) return VarAssignation.XOR_EQUAL;}
1337       break;
1338     case ORASSIGN:
1339       jj_consume_token(ORASSIGN);
1340                         {if (true) return VarAssignation.OR_EQUAL;}
1341       break;
1342     case DOTASSIGN:
1343       jj_consume_token(DOTASSIGN);
1344                         {if (true) return VarAssignation.DOT_EQUAL;}
1345       break;
1346     case TILDEEQUAL:
1347       jj_consume_token(TILDEEQUAL);
1348                         {if (true) return VarAssignation.TILDE_EQUAL;}
1349       break;
1350     default:
1351       jj_la1[28] = jj_gen;
1352       jj_consume_token(-1);
1353       throw new ParseException();
1354     }
1355     throw new Error("Missing return statement in function");
1356   }
1357
1358   static final public Expression ConditionalExpression() throws ParseException {
1359   final Expression expr;
1360   Expression expr2 = null;
1361   Expression expr3 = null;
1362     expr = ConditionalOrExpression();
1363     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1364     case HOOK:
1365       jj_consume_token(HOOK);
1366       expr2 = Expression();
1367       jj_consume_token(COLON);
1368       expr3 = ConditionalExpression();
1369       break;
1370     default:
1371       jj_la1[29] = jj_gen;
1372       ;
1373     }
1374   if (expr3 == null) {
1375     {if (true) return expr;}
1376   }
1377   {if (true) return new ConditionalExpression(expr,expr2,expr3);}
1378     throw new Error("Missing return statement in function");
1379   }
1380
1381   static final public Expression ConditionalOrExpression() throws ParseException {
1382   Expression expr,expr2;
1383   int operator;
1384     expr = ConditionalAndExpression();
1385     label_8:
1386     while (true) {
1387       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1388       case OR_OR:
1389       case _ORL:
1390         ;
1391         break;
1392       default:
1393         jj_la1[30] = jj_gen;
1394         break label_8;
1395       }
1396       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1397       case OR_OR:
1398         jj_consume_token(OR_OR);
1399                  operator = OperatorIds.OR_OR;
1400         break;
1401       case _ORL:
1402         jj_consume_token(_ORL);
1403                  operator = OperatorIds.ORL;
1404         break;
1405       default:
1406         jj_la1[31] = jj_gen;
1407         jj_consume_token(-1);
1408         throw new ParseException();
1409       }
1410       expr2 = ConditionalAndExpression();
1411       expr = new BinaryExpression(expr,expr2,operator);
1412     }
1413    {if (true) return expr;}
1414     throw new Error("Missing return statement in function");
1415   }
1416
1417   static final public Expression ConditionalAndExpression() throws ParseException {
1418   Expression expr,expr2;
1419   int operator;
1420     expr = ConcatExpression();
1421     label_9:
1422     while (true) {
1423       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1424       case AND_AND:
1425       case _ANDL:
1426         ;
1427         break;
1428       default:
1429         jj_la1[32] = jj_gen;
1430         break label_9;
1431       }
1432       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1433       case AND_AND:
1434         jj_consume_token(AND_AND);
1435                 operator = OperatorIds.AND_AND;
1436         break;
1437       case _ANDL:
1438         jj_consume_token(_ANDL);
1439                 operator = OperatorIds.ANDL;
1440         break;
1441       default:
1442         jj_la1[33] = jj_gen;
1443         jj_consume_token(-1);
1444         throw new ParseException();
1445       }
1446       expr2 = ConcatExpression();
1447                                expr = new BinaryExpression(expr,expr2,operator);
1448     }
1449    {if (true) return expr;}
1450     throw new Error("Missing return statement in function");
1451   }
1452
1453   static final public Expression ConcatExpression() throws ParseException {
1454   Expression expr,expr2;
1455     expr = InclusiveOrExpression();
1456     label_10:
1457     while (true) {
1458       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1459       case DOT:
1460         ;
1461         break;
1462       default:
1463         jj_la1[34] = jj_gen;
1464         break label_10;
1465       }
1466       jj_consume_token(DOT);
1467       expr2 = InclusiveOrExpression();
1468      expr = new BinaryExpression(expr,expr2,OperatorIds.DOT);
1469     }
1470    {if (true) return expr;}
1471     throw new Error("Missing return statement in function");
1472   }
1473
1474   static final public Expression InclusiveOrExpression() throws ParseException {
1475   Expression expr,expr2;
1476     expr = ExclusiveOrExpression();
1477     label_11:
1478     while (true) {
1479       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1480       case BIT_OR:
1481         ;
1482         break;
1483       default:
1484         jj_la1[35] = jj_gen;
1485         break label_11;
1486       }
1487       jj_consume_token(BIT_OR);
1488       expr2 = ExclusiveOrExpression();
1489     expr = new BinaryExpression(expr,expr2,OperatorIds.OR);
1490     }
1491    {if (true) return expr;}
1492     throw new Error("Missing return statement in function");
1493   }
1494
1495   static final public Expression ExclusiveOrExpression() throws ParseException {
1496   Expression expr,expr2;
1497     expr = AndExpression();
1498     label_12:
1499     while (true) {
1500       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1501       case XOR:
1502         ;
1503         break;
1504       default:
1505         jj_la1[36] = jj_gen;
1506         break label_12;
1507       }
1508       jj_consume_token(XOR);
1509       expr2 = AndExpression();
1510      expr = new BinaryExpression(expr,expr2,OperatorIds.XOR);
1511     }
1512    {if (true) return expr;}
1513     throw new Error("Missing return statement in function");
1514   }
1515
1516   static final public Expression AndExpression() throws ParseException {
1517   Expression expr,expr2;
1518     expr = EqualityExpression();
1519     label_13:
1520     while (true) {
1521       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1522       case BIT_AND:
1523         ;
1524         break;
1525       default:
1526         jj_la1[37] = jj_gen;
1527         break label_13;
1528       }
1529       jj_consume_token(BIT_AND);
1530       expr2 = EqualityExpression();
1531      expr = new BinaryExpression(expr,expr2,OperatorIds.AND);
1532     }
1533    {if (true) return expr;}
1534     throw new Error("Missing return statement in function");
1535   }
1536
1537   static final public Expression EqualityExpression() throws ParseException {
1538   Expression expr,expr2;
1539   int operator;
1540     expr = RelationalExpression();
1541     label_14:
1542     while (true) {
1543       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1544       case EQUAL_EQUAL:
1545       case NOT_EQUAL:
1546       case DIF:
1547       case BANGDOUBLEEQUAL:
1548       case TRIPLEEQUAL:
1549         ;
1550         break;
1551       default:
1552         jj_la1[38] = jj_gen;
1553         break label_14;
1554       }
1555       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1556       case EQUAL_EQUAL:
1557         jj_consume_token(EQUAL_EQUAL);
1558                           operator = OperatorIds.EQUAL_EQUAL;
1559         break;
1560       case DIF:
1561         jj_consume_token(DIF);
1562                           operator = OperatorIds.DIF;
1563         break;
1564       case NOT_EQUAL:
1565         jj_consume_token(NOT_EQUAL);
1566                           operator = OperatorIds.DIF;
1567         break;
1568       case BANGDOUBLEEQUAL:
1569         jj_consume_token(BANGDOUBLEEQUAL);
1570                           operator = OperatorIds.BANG_EQUAL_EQUAL;
1571         break;
1572       case TRIPLEEQUAL:
1573         jj_consume_token(TRIPLEEQUAL);
1574                           operator = OperatorIds.EQUAL_EQUAL_EQUAL;
1575         break;
1576       default:
1577         jj_la1[39] = jj_gen;
1578         jj_consume_token(-1);
1579         throw new ParseException();
1580       }
1581       try {
1582         expr2 = RelationalExpression();
1583       } catch (ParseException e) {
1584     if (errorMessage != null) {
1585       {if (true) throw e;}
1586     }
1587     errorMessage = "unexpected token : '"+ e.currentToken.next.image +"', expression expected";
1588     errorLevel   = ERROR;
1589     errorStart = SimpleCharStream.getPosition() - e.currentToken.next.image.length() + 1;
1590     errorEnd   = SimpleCharStream.getPosition() + 1;
1591     {if (true) throw e;}
1592       }
1593     expr = new BinaryExpression(expr,expr2,operator);
1594     }
1595    {if (true) return expr;}
1596     throw new Error("Missing return statement in function");
1597   }
1598
1599   static final public Expression RelationalExpression() throws ParseException {
1600   Expression expr,expr2;
1601   int operator;
1602     expr = ShiftExpression();
1603     label_15:
1604     while (true) {
1605       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1606       case GT:
1607       case LT:
1608       case LE:
1609       case GE:
1610         ;
1611         break;
1612       default:
1613         jj_la1[40] = jj_gen;
1614         break label_15;
1615       }
1616       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1617       case LT:
1618         jj_consume_token(LT);
1619           operator = OperatorIds.LESS;
1620         break;
1621       case GT:
1622         jj_consume_token(GT);
1623           operator = OperatorIds.GREATER;
1624         break;
1625       case LE:
1626         jj_consume_token(LE);
1627           operator = OperatorIds.LESS_EQUAL;
1628         break;
1629       case GE:
1630         jj_consume_token(GE);
1631           operator = OperatorIds.GREATER_EQUAL;
1632         break;
1633       default:
1634         jj_la1[41] = jj_gen;
1635         jj_consume_token(-1);
1636         throw new ParseException();
1637       }
1638       expr2 = ShiftExpression();
1639    expr = new BinaryExpression(expr,expr2,operator);
1640     }
1641    {if (true) return expr;}
1642     throw new Error("Missing return statement in function");
1643   }
1644
1645   static final public Expression ShiftExpression() throws ParseException {
1646   Expression expr,expr2;
1647   int operator;
1648     expr = AdditiveExpression();
1649     label_16:
1650     while (true) {
1651       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1652       case LSHIFT:
1653       case RSIGNEDSHIFT:
1654       case RUNSIGNEDSHIFT:
1655         ;
1656         break;
1657       default:
1658         jj_la1[42] = jj_gen;
1659         break label_16;
1660       }
1661       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1662       case LSHIFT:
1663         jj_consume_token(LSHIFT);
1664                       operator = OperatorIds.LEFT_SHIFT;
1665         break;
1666       case RSIGNEDSHIFT:
1667         jj_consume_token(RSIGNEDSHIFT);
1668                       operator = OperatorIds.RIGHT_SHIFT;
1669         break;
1670       case RUNSIGNEDSHIFT:
1671         jj_consume_token(RUNSIGNEDSHIFT);
1672                       operator = OperatorIds.UNSIGNED_RIGHT_SHIFT;
1673         break;
1674       default:
1675         jj_la1[43] = jj_gen;
1676         jj_consume_token(-1);
1677         throw new ParseException();
1678       }
1679       expr2 = AdditiveExpression();
1680    expr = new BinaryExpression(expr,expr2,operator);
1681     }
1682    {if (true) return expr;}
1683     throw new Error("Missing return statement in function");
1684   }
1685
1686   static final public Expression AdditiveExpression() throws ParseException {
1687   Expression expr,expr2;
1688   int operator;
1689     expr = MultiplicativeExpression();
1690     label_17:
1691     while (true) {
1692       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1693       case PLUS:
1694       case MINUS:
1695         ;
1696         break;
1697       default:
1698         jj_la1[44] = jj_gen;
1699         break label_17;
1700       }
1701       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1702       case PLUS:
1703         jj_consume_token(PLUS);
1704               operator = OperatorIds.PLUS;
1705         break;
1706       case MINUS:
1707         jj_consume_token(MINUS);
1708               operator = OperatorIds.MINUS;
1709         break;
1710       default:
1711         jj_la1[45] = jj_gen;
1712         jj_consume_token(-1);
1713         throw new ParseException();
1714       }
1715       expr2 = MultiplicativeExpression();
1716    expr = new BinaryExpression(expr,expr2,operator);
1717     }
1718    {if (true) return expr;}
1719     throw new Error("Missing return statement in function");
1720   }
1721
1722   static final public Expression MultiplicativeExpression() throws ParseException {
1723   Expression expr,expr2;
1724   int operator;
1725     try {
1726       expr = UnaryExpression();
1727     } catch (ParseException e) {
1728     if (errorMessage != null) {if (true) throw e;}
1729     errorMessage = "unexpected token '"+e.currentToken.next.image+"'";
1730     errorLevel   = ERROR;
1731     errorStart = SimpleCharStream.getPosition() - e.currentToken.next.image.length() + 1;
1732     errorEnd   = SimpleCharStream.getPosition() + 1;
1733     {if (true) throw e;}
1734     }
1735     label_18:
1736     while (true) {
1737       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1738       case STAR:
1739       case SLASH:
1740       case REMAINDER:
1741         ;
1742         break;
1743       default:
1744         jj_la1[46] = jj_gen;
1745         break label_18;
1746       }
1747       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1748       case STAR:
1749         jj_consume_token(STAR);
1750                    operator = OperatorIds.MULTIPLY;
1751         break;
1752       case SLASH:
1753         jj_consume_token(SLASH);
1754                    operator = OperatorIds.DIVIDE;
1755         break;
1756       case REMAINDER:
1757         jj_consume_token(REMAINDER);
1758                    operator = OperatorIds.REMAINDER;
1759         break;
1760       default:
1761         jj_la1[47] = jj_gen;
1762         jj_consume_token(-1);
1763         throw new ParseException();
1764       }
1765       expr2 = UnaryExpression();
1766      expr = new BinaryExpression(expr,expr2,operator);
1767     }
1768    {if (true) return expr;}
1769     throw new Error("Missing return statement in function");
1770   }
1771
1772 /**
1773  * An unary expression starting with @, & or nothing
1774  */
1775   static final public Expression UnaryExpression() throws ParseException {
1776   Expression expr;
1777   final int pos = SimpleCharStream.getPosition();
1778     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1779     case BIT_AND:
1780       jj_consume_token(BIT_AND);
1781       expr = UnaryExpressionNoPrefix();
1782    {if (true) return new PrefixedUnaryExpression(expr,OperatorIds.AND,pos);}
1783       break;
1784     case ARRAY:
1785     case NEW:
1786     case NULL:
1787     case TRUE:
1788     case FALSE:
1789     case AT:
1790     case DOLLAR:
1791     case BANG:
1792     case INCR:
1793     case DECR:
1794     case PLUS:
1795     case MINUS:
1796     case INTEGER_LITERAL:
1797     case FLOATING_POINT_LITERAL:
1798     case STRING_LITERAL:
1799     case IDENTIFIER:
1800     case LPAREN:
1801     case DOLLAR_ID:
1802       expr = AtUnaryExpression();
1803                               {if (true) return expr;}
1804       break;
1805     default:
1806       jj_la1[48] = jj_gen;
1807       jj_consume_token(-1);
1808       throw new ParseException();
1809     }
1810     throw new Error("Missing return statement in function");
1811   }
1812
1813   static final public Expression AtUnaryExpression() throws ParseException {
1814   Expression expr;
1815   final int pos = SimpleCharStream.getPosition();
1816     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1817     case AT:
1818       jj_consume_token(AT);
1819       expr = AtUnaryExpression();
1820    {if (true) return new PrefixedUnaryExpression(expr,OperatorIds.AT,pos);}
1821       break;
1822     case ARRAY:
1823     case NEW:
1824     case NULL:
1825     case TRUE:
1826     case FALSE:
1827     case DOLLAR:
1828     case BANG:
1829     case INCR:
1830     case DECR:
1831     case PLUS:
1832     case MINUS:
1833     case INTEGER_LITERAL:
1834     case FLOATING_POINT_LITERAL:
1835     case STRING_LITERAL:
1836     case IDENTIFIER:
1837     case LPAREN:
1838     case DOLLAR_ID:
1839       expr = UnaryExpressionNoPrefix();
1840    {if (true) return expr;}
1841       break;
1842     default:
1843       jj_la1[49] = jj_gen;
1844       jj_consume_token(-1);
1845       throw new ParseException();
1846     }
1847     throw new Error("Missing return statement in function");
1848   }
1849
1850   static final public Expression UnaryExpressionNoPrefix() throws ParseException {
1851   Expression expr;
1852   int operator;
1853   final int pos = SimpleCharStream.getPosition();
1854     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1855     case PLUS:
1856     case MINUS:
1857       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1858       case PLUS:
1859         jj_consume_token(PLUS);
1860               operator = OperatorIds.PLUS;
1861         break;
1862       case MINUS:
1863         jj_consume_token(MINUS);
1864               operator = OperatorIds.MINUS;
1865         break;
1866       default:
1867         jj_la1[50] = jj_gen;
1868         jj_consume_token(-1);
1869         throw new ParseException();
1870       }
1871       expr = UnaryExpression();
1872    {if (true) return new PrefixedUnaryExpression(expr,operator,pos);}
1873       break;
1874     case INCR:
1875     case DECR:
1876       expr = PreIncDecExpression();
1877    {if (true) return expr;}
1878       break;
1879     case ARRAY:
1880     case NEW:
1881     case NULL:
1882     case TRUE:
1883     case FALSE:
1884     case DOLLAR:
1885     case BANG:
1886     case INTEGER_LITERAL:
1887     case FLOATING_POINT_LITERAL:
1888     case STRING_LITERAL:
1889     case IDENTIFIER:
1890     case LPAREN:
1891     case DOLLAR_ID:
1892       expr = UnaryExpressionNotPlusMinus();
1893    {if (true) return expr;}
1894       break;
1895     default:
1896       jj_la1[51] = jj_gen;
1897       jj_consume_token(-1);
1898       throw new ParseException();
1899     }
1900     throw new Error("Missing return statement in function");
1901   }
1902
1903   static final public Expression PreIncDecExpression() throws ParseException {
1904 final Expression expr;
1905 final int operator;
1906   final int pos = SimpleCharStream.getPosition();
1907     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1908     case INCR:
1909       jj_consume_token(INCR);
1910              operator = OperatorIds.PLUS_PLUS;
1911       break;
1912     case DECR:
1913       jj_consume_token(DECR);
1914              operator = OperatorIds.MINUS_MINUS;
1915       break;
1916     default:
1917       jj_la1[52] = jj_gen;
1918       jj_consume_token(-1);
1919       throw new ParseException();
1920     }
1921     expr = PrimaryExpression();
1922    {if (true) return new PrefixedUnaryExpression(expr,operator,pos);}
1923     throw new Error("Missing return statement in function");
1924   }
1925
1926   static final public Expression UnaryExpressionNotPlusMinus() throws ParseException {
1927   Expression expr;
1928   final int pos = SimpleCharStream.getPosition();
1929     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1930     case BANG:
1931       jj_consume_token(BANG);
1932       expr = UnaryExpression();
1933                                    {if (true) return new PrefixedUnaryExpression(expr,OperatorIds.NOT,pos);}
1934       break;
1935     default:
1936       jj_la1[53] = jj_gen;
1937       if (jj_2_4(2147483647)) {
1938         expr = CastExpression();
1939                                    {if (true) return expr;}
1940       } else {
1941         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1942         case ARRAY:
1943         case NEW:
1944         case DOLLAR:
1945         case IDENTIFIER:
1946         case DOLLAR_ID:
1947           expr = PostfixExpression();
1948                                    {if (true) return expr;}
1949           break;
1950         case NULL:
1951         case TRUE:
1952         case FALSE:
1953         case INTEGER_LITERAL:
1954         case FLOATING_POINT_LITERAL:
1955         case STRING_LITERAL:
1956           expr = Literal();
1957                                    {if (true) return expr;}
1958           break;
1959         case LPAREN:
1960           jj_consume_token(LPAREN);
1961           expr = Expression();
1962           try {
1963             jj_consume_token(RPAREN);
1964           } catch (ParseException e) {
1965     errorMessage = "')' expected";
1966     errorLevel   = ERROR;
1967     errorStart   = SimpleCharStream.getPosition() - e.currentToken.next.image.length() + 1;
1968     errorEnd     = SimpleCharStream.getPosition() + 1;
1969     {if (true) throw e;}
1970           }
1971    {if (true) return expr;}
1972           break;
1973         default:
1974           jj_la1[54] = jj_gen;
1975           jj_consume_token(-1);
1976           throw new ParseException();
1977         }
1978       }
1979     }
1980     throw new Error("Missing return statement in function");
1981   }
1982
1983   static final public CastExpression CastExpression() throws ParseException {
1984 final ConstantIdentifier type;
1985 final Expression expr;
1986 final int pos = SimpleCharStream.getPosition();
1987     jj_consume_token(LPAREN);
1988     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1989     case STRING:
1990     case OBJECT:
1991     case BOOL:
1992     case BOOLEAN:
1993     case REAL:
1994     case DOUBLE:
1995     case FLOAT:
1996     case INT:
1997     case INTEGER:
1998       type = Type();
1999       break;
2000     case ARRAY:
2001       jj_consume_token(ARRAY);
2002              type = new ConstantIdentifier(Types.ARRAY,pos,SimpleCharStream.getPosition());
2003       break;
2004     default:
2005       jj_la1[55] = jj_gen;
2006       jj_consume_token(-1);
2007       throw new ParseException();
2008     }
2009     jj_consume_token(RPAREN);
2010     expr = UnaryExpression();
2011    {if (true) return new CastExpression(type,expr,pos,SimpleCharStream.getPosition());}
2012     throw new Error("Missing return statement in function");
2013   }
2014
2015   static final public Expression PostfixExpression() throws ParseException {
2016   Expression expr;
2017   int operator = -1;
2018   final int pos = SimpleCharStream.getPosition();
2019     expr = PrimaryExpression();
2020     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2021     case INCR:
2022     case DECR:
2023       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2024       case INCR:
2025         jj_consume_token(INCR);
2026             operator = OperatorIds.PLUS_PLUS;
2027         break;
2028       case DECR:
2029         jj_consume_token(DECR);
2030             operator = OperatorIds.MINUS_MINUS;
2031         break;
2032       default:
2033         jj_la1[56] = jj_gen;
2034         jj_consume_token(-1);
2035         throw new ParseException();
2036       }
2037       break;
2038     default:
2039       jj_la1[57] = jj_gen;
2040       ;
2041     }
2042     if (operator == -1) {
2043       {if (true) return expr;}
2044     }
2045     {if (true) return new PostfixedUnaryExpression(expr,operator,pos);}
2046     throw new Error("Missing return statement in function");
2047   }
2048
2049   static final public Expression PrimaryExpression() throws ParseException {
2050   final Token identifier;
2051   Expression expr;
2052   final int pos = SimpleCharStream.getPosition();
2053     if (jj_2_5(2)) {
2054       identifier = jj_consume_token(IDENTIFIER);
2055       jj_consume_token(STATICCLASSACCESS);
2056       expr = ClassIdentifier();
2057    expr = new ClassAccess(new ConstantIdentifier(identifier.image.toCharArray(),
2058                                                  pos,
2059                                                  SimpleCharStream.getPosition()),
2060                           expr,
2061                           ClassAccess.STATIC);
2062       label_19:
2063       while (true) {
2064         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2065         case CLASSACCESS:
2066         case LPAREN:
2067         case LBRACKET:
2068           ;
2069           break;
2070         default:
2071           jj_la1[58] = jj_gen;
2072           break label_19;
2073         }
2074         expr = PrimarySuffix(expr);
2075       }
2076    {if (true) return expr;}
2077     } else {
2078       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2079       case NEW:
2080       case DOLLAR:
2081       case IDENTIFIER:
2082       case DOLLAR_ID:
2083         expr = PrimaryPrefix();
2084         label_20:
2085         while (true) {
2086           switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2087           case CLASSACCESS:
2088           case LPAREN:
2089           case LBRACKET:
2090             ;
2091             break;
2092           default:
2093             jj_la1[59] = jj_gen;
2094             break label_20;
2095           }
2096           expr = PrimarySuffix(expr);
2097         }
2098    {if (true) return expr;}
2099         break;
2100       case ARRAY:
2101         expr = ArrayDeclarator();
2102    {if (true) return expr;}
2103         break;
2104       default:
2105         jj_la1[60] = jj_gen;
2106         jj_consume_token(-1);
2107         throw new ParseException();
2108       }
2109     }
2110     throw new Error("Missing return statement in function");
2111   }
2112
2113   static final public ArrayInitializer ArrayDeclarator() throws ParseException {
2114   final ArrayVariableDeclaration[] vars;
2115   final int pos = SimpleCharStream.getPosition();
2116     jj_consume_token(ARRAY);
2117     vars = ArrayInitializer();
2118    {if (true) return new ArrayInitializer(vars,pos,SimpleCharStream.getPosition());}
2119     throw new Error("Missing return statement in function");
2120   }
2121
2122   static final public Expression PrimaryPrefix() throws ParseException {
2123   final Expression expr;
2124   final Token token;
2125   final String var;
2126   final int pos = SimpleCharStream.getPosition();
2127     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2128     case IDENTIFIER:
2129       token = jj_consume_token(IDENTIFIER);
2130                                   {if (true) return new ConstantIdentifier(token.image.toCharArray(),
2131                                                                 pos,
2132                                                                 SimpleCharStream.getPosition());}
2133       break;
2134     case NEW:
2135       jj_consume_token(NEW);
2136       expr = ClassIdentifier();
2137                                   {if (true) return new PrefixedUnaryExpression(expr,
2138                                                                      OperatorIds.NEW,
2139                                                                      pos);}
2140       break;
2141     case DOLLAR:
2142     case DOLLAR_ID:
2143       var = VariableDeclaratorId();
2144                                  {if (true) return new ConstantIdentifier(var.toCharArray(),
2145                                                                pos,
2146                                                                SimpleCharStream.getPosition());}
2147       break;
2148     default:
2149       jj_la1[61] = jj_gen;
2150       jj_consume_token(-1);
2151       throw new ParseException();
2152     }
2153     throw new Error("Missing return statement in function");
2154   }
2155
2156   static final public PrefixedUnaryExpression classInstantiation() throws ParseException {
2157   Expression expr;
2158   final StringBuffer buff;
2159   final int pos = SimpleCharStream.getPosition();
2160     jj_consume_token(NEW);
2161     expr = ClassIdentifier();
2162     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2163     case ARRAY:
2164     case NEW:
2165     case DOLLAR:
2166     case IDENTIFIER:
2167     case DOLLAR_ID:
2168      buff = new StringBuffer(expr.toStringExpression());
2169       expr = PrimaryExpression();
2170      buff.append(expr.toStringExpression());
2171     expr = new ConstantIdentifier(buff.toString().toCharArray(),
2172                                   pos,
2173                                   SimpleCharStream.getPosition());
2174       break;
2175     default:
2176       jj_la1[62] = jj_gen;
2177       ;
2178     }
2179    {if (true) return new PrefixedUnaryExpression(expr,
2180                                       OperatorIds.NEW,
2181                                       pos);}
2182     throw new Error("Missing return statement in function");
2183   }
2184
2185   static final public ConstantIdentifier ClassIdentifier() throws ParseException {
2186   final String expr;
2187   final Token token;
2188   final int pos = SimpleCharStream.getPosition();
2189     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2190     case IDENTIFIER:
2191       token = jj_consume_token(IDENTIFIER);
2192                                  {if (true) return new ConstantIdentifier(token.image.toCharArray(),
2193                                                                pos,
2194                                                                SimpleCharStream.getPosition());}
2195       break;
2196     case DOLLAR:
2197     case DOLLAR_ID:
2198       expr = VariableDeclaratorId();
2199                                  {if (true) return new ConstantIdentifier(expr.toCharArray(),
2200                                                                pos,
2201                                                                SimpleCharStream.getPosition());}
2202       break;
2203     default:
2204       jj_la1[63] = jj_gen;
2205       jj_consume_token(-1);
2206       throw new ParseException();
2207     }
2208     throw new Error("Missing return statement in function");
2209   }
2210
2211   static final public AbstractSuffixExpression PrimarySuffix(Expression prefix) throws ParseException {
2212   final AbstractSuffixExpression expr;
2213     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2214     case LPAREN:
2215       expr = Arguments(prefix);
2216                                  {if (true) return expr;}
2217       break;
2218     case CLASSACCESS:
2219     case LBRACKET:
2220       expr = VariableSuffix(prefix);
2221                                  {if (true) return expr;}
2222       break;
2223     default:
2224       jj_la1[64] = jj_gen;
2225       jj_consume_token(-1);
2226       throw new ParseException();
2227     }
2228     throw new Error("Missing return statement in function");
2229   }
2230
2231   static final public AbstractSuffixExpression VariableSuffix(Expression prefix) throws ParseException {
2232   String expr = null;
2233   final int pos = SimpleCharStream.getPosition();
2234   Expression expression = null;
2235     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2236     case CLASSACCESS:
2237       jj_consume_token(CLASSACCESS);
2238       try {
2239         expr = VariableName();
2240       } catch (ParseException e) {
2241     errorMessage = "unexpected token : '"+ e.currentToken.next.image +"', function call or field access expected";
2242     errorLevel   = ERROR;
2243     errorStart = SimpleCharStream.getPosition() - e.currentToken.next.image.length() + 1;
2244     errorEnd   = SimpleCharStream.getPosition() + 1;
2245     {if (true) throw e;}
2246       }
2247    {if (true) return new ClassAccess(prefix,
2248                           new ConstantIdentifier(expr.toCharArray(),pos,SimpleCharStream.getPosition()),
2249                           ClassAccess.NORMAL);}
2250       break;
2251     case LBRACKET:
2252       jj_consume_token(LBRACKET);
2253       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2254       case ARRAY:
2255       case LIST:
2256       case PRINT:
2257       case NEW:
2258       case NULL:
2259       case TRUE:
2260       case FALSE:
2261       case STRING:
2262       case OBJECT:
2263       case BOOL:
2264       case BOOLEAN:
2265       case REAL:
2266       case DOUBLE:
2267       case FLOAT:
2268       case INT:
2269       case INTEGER:
2270       case AT:
2271       case DOLLAR:
2272       case BANG:
2273       case INCR:
2274       case DECR:
2275       case PLUS:
2276       case MINUS:
2277       case BIT_AND:
2278       case INTEGER_LITERAL:
2279       case FLOATING_POINT_LITERAL:
2280       case STRING_LITERAL:
2281       case IDENTIFIER:
2282       case LPAREN:
2283       case DOLLAR_ID:
2284         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2285         case ARRAY:
2286         case LIST:
2287         case PRINT:
2288         case NEW:
2289         case NULL:
2290         case TRUE:
2291         case FALSE:
2292         case AT:
2293         case DOLLAR:
2294         case BANG:
2295         case INCR:
2296         case DECR:
2297         case PLUS:
2298         case MINUS:
2299         case BIT_AND:
2300         case INTEGER_LITERAL:
2301         case FLOATING_POINT_LITERAL:
2302         case STRING_LITERAL:
2303         case IDENTIFIER:
2304         case LPAREN:
2305         case DOLLAR_ID:
2306           expression = Expression();
2307           break;
2308         case STRING:
2309         case OBJECT:
2310         case BOOL:
2311         case BOOLEAN:
2312         case REAL:
2313         case DOUBLE:
2314         case FLOAT:
2315         case INT:
2316         case INTEGER:
2317           expression = Type();
2318           break;
2319         default:
2320           jj_la1[65] = jj_gen;
2321           jj_consume_token(-1);
2322           throw new ParseException();
2323         }
2324         break;
2325       default:
2326         jj_la1[66] = jj_gen;
2327         ;
2328       }
2329       try {
2330         jj_consume_token(RBRACKET);
2331       } catch (ParseException e) {
2332     errorMessage = "']' expected";
2333     errorLevel   = ERROR;
2334     errorStart = SimpleCharStream.getPosition() - e.currentToken.next.image.length() + 1;
2335     errorEnd   = SimpleCharStream.getPosition() + 1;
2336     {if (true) throw e;}
2337       }
2338    {if (true) return new ArrayDeclarator(prefix,expression,SimpleCharStream.getPosition());}
2339       break;
2340     default:
2341       jj_la1[67] = jj_gen;
2342       jj_consume_token(-1);
2343       throw new ParseException();
2344     }
2345     throw new Error("Missing return statement in function");
2346   }
2347
2348   static final public Literal Literal() throws ParseException {
2349   final Token token;
2350   final int pos;
2351     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2352     case INTEGER_LITERAL:
2353       token = jj_consume_token(INTEGER_LITERAL);
2354                                     pos = SimpleCharStream.getPosition();
2355                                     {if (true) return new NumberLiteral(token.image.toCharArray(),pos-token.image.length(),pos);}
2356       break;
2357     case FLOATING_POINT_LITERAL:
2358       token = jj_consume_token(FLOATING_POINT_LITERAL);
2359                                     pos = SimpleCharStream.getPosition();
2360                                     {if (true) return new NumberLiteral(token.image.toCharArray(),pos-token.image.length(),pos);}
2361       break;
2362     case STRING_LITERAL:
2363       token = jj_consume_token(STRING_LITERAL);
2364                                     pos = SimpleCharStream.getPosition();
2365                                     {if (true) return new StringLiteral(token.image.toCharArray(),pos-token.image.length());}
2366       break;
2367     case TRUE:
2368       jj_consume_token(TRUE);
2369                                     pos = SimpleCharStream.getPosition();
2370                                     {if (true) return new TrueLiteral(pos-4,pos);}
2371       break;
2372     case FALSE:
2373       jj_consume_token(FALSE);
2374                                     pos = SimpleCharStream.getPosition();
2375                                     {if (true) return new FalseLiteral(pos-4,pos);}
2376       break;
2377     case NULL:
2378       jj_consume_token(NULL);
2379                                     pos = SimpleCharStream.getPosition();
2380                                     {if (true) return new NullLiteral(pos-4,pos);}
2381       break;
2382     default:
2383       jj_la1[68] = jj_gen;
2384       jj_consume_token(-1);
2385       throw new ParseException();
2386     }
2387     throw new Error("Missing return statement in function");
2388   }
2389
2390   static final public FunctionCall Arguments(Expression func) throws ParseException {
2391 Expression[] args = null;
2392     jj_consume_token(LPAREN);
2393     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2394     case ARRAY:
2395     case LIST:
2396     case PRINT:
2397     case NEW:
2398     case NULL:
2399     case TRUE:
2400     case FALSE:
2401     case AT:
2402     case DOLLAR:
2403     case BANG:
2404     case INCR:
2405     case DECR:
2406     case PLUS:
2407     case MINUS:
2408     case BIT_AND:
2409     case INTEGER_LITERAL:
2410     case FLOATING_POINT_LITERAL:
2411     case STRING_LITERAL:
2412     case IDENTIFIER:
2413     case LPAREN:
2414     case DOLLAR_ID:
2415       args = ArgumentList();
2416       break;
2417     default:
2418       jj_la1[69] = jj_gen;
2419       ;
2420     }
2421     try {
2422       jj_consume_token(RPAREN);
2423     } catch (ParseException e) {
2424     errorMessage = "unexpected token : '"+ e.currentToken.next.image +"', ')' expected to close the argument list";
2425     errorLevel   = ERROR;
2426     errorStart = SimpleCharStream.getPosition() - e.currentToken.next.image.length() + 1;
2427     errorEnd   = SimpleCharStream.getPosition() + 1;
2428     {if (true) throw e;}
2429     }
2430    {if (true) return new FunctionCall(func,args,SimpleCharStream.getPosition());}
2431     throw new Error("Missing return statement in function");
2432   }
2433
2434 /**
2435  * An argument list is a list of arguments separated by comma :
2436  * argumentDeclaration() (, argumentDeclaration)*
2437  * @return an array of arguments
2438  */
2439   static final public Expression[] ArgumentList() throws ParseException {
2440 Expression arg;
2441 final ArrayList list = new ArrayList();
2442     arg = Expression();
2443    list.add(arg);
2444     label_21:
2445     while (true) {
2446       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2447       case COMMA:
2448         ;
2449         break;
2450       default:
2451         jj_la1[70] = jj_gen;
2452         break label_21;
2453       }
2454       jj_consume_token(COMMA);
2455       try {
2456         arg = Expression();
2457          list.add(arg);
2458       } catch (ParseException e) {
2459         errorMessage = "unexpected token : '"+ e.currentToken.next.image +"'. An expression expected after a comma in argument list";
2460         errorLevel   = ERROR;
2461         errorStart   = SimpleCharStream.getPosition() - e.currentToken.next.image.length() + 1;
2462         errorEnd     = SimpleCharStream.getPosition() + 1;
2463         {if (true) throw e;}
2464       }
2465     }
2466    Expression[] arguments = new Expression[list.size()];
2467    list.toArray(arguments);
2468    {if (true) return arguments;}
2469     throw new Error("Missing return statement in function");
2470   }
2471
2472 /**
2473  * A Statement without break.
2474  */
2475   static final public Statement StatementNoBreak() throws ParseException {
2476   final Statement statement;
2477   Token token = null;
2478     if (jj_2_6(2)) {
2479       statement = Expression();
2480       try {
2481         jj_consume_token(SEMICOLON);
2482       } catch (ParseException e) {
2483     if (e.currentToken.next.kind != PHPParserConstants.PHPEND) {
2484       errorMessage = "unexpected token : '"+ e.currentToken.next.image +"'. A ';' was expected";
2485       errorLevel   = ERROR;
2486       errorStart = SimpleCharStream.getPosition() - e.currentToken.next.image.length() + 1;
2487       errorEnd   = SimpleCharStream.getPosition() + 1;
2488       {if (true) throw e;}
2489     }
2490       }
2491    {if (true) return statement;}
2492     } else if (jj_2_7(2)) {
2493       statement = LabeledStatement();
2494                                   {if (true) return statement;}
2495     } else {
2496       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2497       case LBRACE:
2498         statement = Block();
2499                                   {if (true) return statement;}
2500         break;
2501       case SEMICOLON:
2502         statement = EmptyStatement();
2503                                   {if (true) return statement;}
2504         break;
2505       case ARRAY:
2506       case NEW:
2507       case DOLLAR:
2508       case INCR:
2509       case DECR:
2510       case IDENTIFIER:
2511       case DOLLAR_ID:
2512         statement = StatementExpression();
2513         try {
2514           jj_consume_token(SEMICOLON);
2515         } catch (ParseException e) {
2516     errorMessage = "unexpected token : '"+ e.currentToken.next.image +"'. A ';' was expected";
2517     errorLevel   = ERROR;
2518     errorStart   = SimpleCharStream.getPosition() - e.currentToken.next.image.length() + 1;
2519     errorEnd     = SimpleCharStream.getPosition() + 1;
2520     {if (true) throw e;}
2521         }
2522    {if (true) return statement;}
2523         break;
2524       case SWITCH:
2525         statement = SwitchStatement();
2526                                          {if (true) return statement;}
2527         break;
2528       case IF:
2529         statement = IfStatement();
2530                                          {if (true) return statement;}
2531         break;
2532       case WHILE:
2533         statement = WhileStatement();
2534                                          {if (true) return statement;}
2535         break;
2536       case DO:
2537         statement = DoStatement();
2538                                          {if (true) return statement;}
2539         break;
2540       case FOR:
2541         statement = ForStatement();
2542                                          {if (true) return statement;}
2543         break;
2544       case FOREACH:
2545         statement = ForeachStatement();
2546                                          {if (true) return statement;}
2547         break;
2548       case CONTINUE:
2549         statement = ContinueStatement();
2550                                          {if (true) return statement;}
2551         break;
2552       case RETURN:
2553         statement = ReturnStatement();
2554                                          {if (true) return statement;}
2555         break;
2556       case ECHO:
2557         statement = EchoStatement();
2558                                          {if (true) return statement;}
2559         break;
2560       case INCLUDE:
2561       case REQUIRE:
2562       case INCLUDE_ONCE:
2563       case REQUIRE_ONCE:
2564       case AT:
2565         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2566         case AT:
2567           token = jj_consume_token(AT);
2568           break;
2569         default:
2570           jj_la1[71] = jj_gen;
2571           ;
2572         }
2573         statement = IncludeStatement();
2574    if (token != null) {
2575     ((InclusionStatement)statement).silent = true;
2576   }
2577   {if (true) return statement;}
2578         break;
2579       case STATIC:
2580         statement = StaticStatement();
2581                                          {if (true) return statement;}
2582         break;
2583       case GLOBAL:
2584         statement = GlobalStatement();
2585                                          {if (true) return statement;}
2586         break;
2587       default:
2588         jj_la1[72] = jj_gen;
2589         jj_consume_token(-1);
2590         throw new ParseException();
2591       }
2592     }
2593     throw new Error("Missing return statement in function");
2594   }
2595
2596 /**
2597  * A Normal statement.
2598  */
2599   static final public Statement Statement() throws ParseException {
2600   final Statement statement;
2601     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2602     case IF:
2603     case ARRAY:
2604     case LIST:
2605     case PRINT:
2606     case ECHO:
2607     case INCLUDE:
2608     case REQUIRE:
2609     case INCLUDE_ONCE:
2610     case REQUIRE_ONCE:
2611     case GLOBAL:
2612     case STATIC:
2613     case CONTINUE:
2614     case DO:
2615     case FOR:
2616     case NEW:
2617     case NULL:
2618     case RETURN:
2619     case SWITCH:
2620     case TRUE:
2621     case FALSE:
2622     case WHILE:
2623     case FOREACH:
2624     case AT:
2625     case DOLLAR:
2626     case BANG:
2627     case INCR:
2628     case DECR:
2629     case PLUS:
2630     case MINUS:
2631     case BIT_AND:
2632     case INTEGER_LITERAL:
2633     case FLOATING_POINT_LITERAL:
2634     case STRING_LITERAL:
2635     case IDENTIFIER:
2636     case LPAREN:
2637     case LBRACE:
2638     case SEMICOLON:
2639     case DOLLAR_ID:
2640       statement = StatementNoBreak();
2641                                   {if (true) return statement;}
2642       break;
2643     case BREAK:
2644       statement = BreakStatement();
2645                                   {if (true) return statement;}
2646       break;
2647     default:
2648       jj_la1[73] = jj_gen;
2649       jj_consume_token(-1);
2650       throw new ParseException();
2651     }
2652     throw new Error("Missing return statement in function");
2653   }
2654
2655 /**
2656  * An html block inside a php syntax.
2657  */
2658   static final public HTMLBlock htmlBlock() throws ParseException {
2659   final int startIndex = nodePtr;
2660   AstNode[] blockNodes;
2661   int nbNodes;
2662     jj_consume_token(PHPEND);
2663     label_22:
2664     while (true) {
2665       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2666       case PHPECHOSTART:
2667         ;
2668         break;
2669       default:
2670         jj_la1[74] = jj_gen;
2671         break label_22;
2672       }
2673       phpEchoBlock();
2674     }
2675     try {
2676       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2677       case PHPSTARTLONG:
2678         jj_consume_token(PHPSTARTLONG);
2679         break;
2680       case PHPSTARTSHORT:
2681         jj_consume_token(PHPSTARTSHORT);
2682         break;
2683       default:
2684         jj_la1[75] = jj_gen;
2685         jj_consume_token(-1);
2686         throw new ParseException();
2687       }
2688     } catch (ParseException e) {
2689     errorMessage = "unexpected end of file , '<?php' expected";
2690     errorLevel   = ERROR;
2691     errorStart   = SimpleCharStream.getPosition();
2692     errorEnd     = SimpleCharStream.getPosition();
2693     {if (true) throw e;}
2694     }
2695   nbNodes    = nodePtr - startIndex;
2696   blockNodes = new AstNode[nbNodes];
2697   System.arraycopy(nodes,startIndex,blockNodes,0,nbNodes);
2698   nodePtr = startIndex;
2699   {if (true) return new HTMLBlock(blockNodes);}
2700     throw new Error("Missing return statement in function");
2701   }
2702
2703 /**
2704  * An include statement. It's "include" an expression;
2705  */
2706   static final public InclusionStatement IncludeStatement() throws ParseException {
2707   final Expression expr;
2708   final int keyword;
2709   final int pos = SimpleCharStream.getPosition();
2710   final InclusionStatement inclusionStatement;
2711     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2712     case REQUIRE:
2713       jj_consume_token(REQUIRE);
2714                          keyword = InclusionStatement.REQUIRE;
2715       break;
2716     case REQUIRE_ONCE:
2717       jj_consume_token(REQUIRE_ONCE);
2718                          keyword = InclusionStatement.REQUIRE_ONCE;
2719       break;
2720     case INCLUDE:
2721       jj_consume_token(INCLUDE);
2722                          keyword = InclusionStatement.INCLUDE;
2723       break;
2724     case INCLUDE_ONCE:
2725       jj_consume_token(INCLUDE_ONCE);
2726                          keyword = InclusionStatement.INCLUDE_ONCE;
2727       break;
2728     default:
2729       jj_la1[76] = jj_gen;
2730       jj_consume_token(-1);
2731       throw new ParseException();
2732     }
2733     try {
2734       expr = Expression();
2735     } catch (ParseException e) {
2736     if (errorMessage != null) {
2737       {if (true) throw e;}
2738     }
2739     errorMessage = "unexpected token '"+ e.currentToken.next.image+"', expression expected";
2740     errorLevel   = ERROR;
2741     errorStart   = SimpleCharStream.getPosition() - e.currentToken.next.image.length() + 1;
2742     errorEnd     = SimpleCharStream.getPosition() + 1;
2743     {if (true) throw e;}
2744     }
2745    inclusionStatement = new InclusionStatement(currentSegment,
2746                                                keyword,
2747                                                expr,
2748                                                pos);
2749    currentSegment.add(inclusionStatement);
2750     try {
2751       jj_consume_token(SEMICOLON);
2752     } catch (ParseException e) {
2753     errorMessage = "unexpected token : '"+ e.currentToken.next.image +"'. A ';' was expected";
2754     errorLevel   = ERROR;
2755     errorStart   = SimpleCharStream.getPosition() - e.currentToken.next.image.length() + 1;
2756     errorEnd     = SimpleCharStream.getPosition() + 1;
2757     {if (true) throw e;}
2758     }
2759    {if (true) return inclusionStatement;}
2760     throw new Error("Missing return statement in function");
2761   }
2762
2763   static final public PrintExpression PrintExpression() throws ParseException {
2764   final Expression expr;
2765   final int pos = SimpleCharStream.getPosition();
2766     jj_consume_token(PRINT);
2767     expr = Expression();
2768                                {if (true) return new PrintExpression(expr,pos,SimpleCharStream.getPosition());}
2769     throw new Error("Missing return statement in function");
2770   }
2771
2772   static final public ListExpression ListExpression() throws ParseException {
2773   String expr = null;
2774   Expression expression = null;
2775   ArrayList list = new ArrayList();
2776   final int pos = SimpleCharStream.getPosition();
2777     jj_consume_token(LIST);
2778     try {
2779       jj_consume_token(LPAREN);
2780     } catch (ParseException e) {
2781     errorMessage = "unexpected token : '"+ e.currentToken.next.image +"', '(' expected";
2782     errorLevel   = ERROR;
2783     errorStart   = SimpleCharStream.getPosition() - e.currentToken.next.image.length() + 1;
2784     errorEnd     = SimpleCharStream.getPosition() + 1;
2785     {if (true) throw e;}
2786     }
2787     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2788     case DOLLAR:
2789     case DOLLAR_ID:
2790       expr = VariableDeclaratorId();
2791      list.add(expr);
2792       break;
2793     default:
2794       jj_la1[77] = jj_gen;
2795       ;
2796     }
2797    if (expr == null) list.add(null);
2798     label_23:
2799     while (true) {
2800       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2801       case COMMA:
2802         ;
2803         break;
2804       default:
2805         jj_la1[78] = jj_gen;
2806         break label_23;
2807       }
2808       try {
2809         jj_consume_token(COMMA);
2810       } catch (ParseException e) {
2811       errorMessage = "unexpected token : '"+ e.currentToken.next.image +"', ',' expected";
2812       errorLevel   = ERROR;
2813       errorStart   = SimpleCharStream.getPosition() - e.currentToken.next.image.length() + 1;
2814       errorEnd     = SimpleCharStream.getPosition() + 1;
2815       {if (true) throw e;}
2816       }
2817       expr = VariableDeclaratorId();
2818      list.add(expr);
2819     }
2820     try {
2821       jj_consume_token(RPAREN);
2822     } catch (ParseException e) {
2823     errorMessage = "unexpected token : '"+ e.currentToken.next.image +"', ')' expected";
2824     errorLevel   = ERROR;
2825     errorStart = SimpleCharStream.getPosition() - e.currentToken.next.image.length() + 1;
2826     errorEnd   = SimpleCharStream.getPosition() + 1;
2827     {if (true) throw e;}
2828     }
2829     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2830     case ASSIGN:
2831       jj_consume_token(ASSIGN);
2832       expression = Expression();
2833     String[] strings = new String[list.size()];
2834     list.toArray(strings);
2835     {if (true) return new ListExpression(strings,
2836                               expression,
2837                               pos,
2838                               SimpleCharStream.getPosition());}
2839       break;
2840     default:
2841       jj_la1[79] = jj_gen;
2842       ;
2843     }
2844     String[] strings = new String[list.size()];
2845     list.toArray(strings);
2846     {if (true) return new ListExpression(strings,pos,SimpleCharStream.getPosition());}
2847     throw new Error("Missing return statement in function");
2848   }
2849
2850 /**
2851  * An echo statement.
2852  * echo anyexpression (, otherexpression)*
2853  */
2854   static final public EchoStatement EchoStatement() throws ParseException {
2855   final ArrayList expressions = new ArrayList();
2856   Expression expr;
2857   final int pos = SimpleCharStream.getPosition();
2858     jj_consume_token(ECHO);
2859     expr = Expression();
2860    expressions.add(expr);
2861     label_24:
2862     while (true) {
2863       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2864       case COMMA:
2865         ;
2866         break;
2867       default:
2868         jj_la1[80] = jj_gen;
2869         break label_24;
2870       }
2871       jj_consume_token(COMMA);
2872       expr = Expression();
2873      expressions.add(expr);
2874     }
2875     try {
2876       jj_consume_token(SEMICOLON);
2877     } catch (ParseException e) {
2878     if (e.currentToken.next.kind != 4) {
2879       errorMessage = "';' expected after 'echo' statement";
2880       errorLevel   = ERROR;
2881       errorStart   = SimpleCharStream.getPosition() - e.currentToken.next.image.length() + 1;
2882       errorEnd     = SimpleCharStream.getPosition() + 1;
2883       {if (true) throw e;}
2884     }
2885     }
2886    Expression[] exprs = new Expression[expressions.size()];
2887    expressions.toArray(exprs);
2888    {if (true) return new EchoStatement(exprs,pos);}
2889     throw new Error("Missing return statement in function");
2890   }
2891
2892   static final public GlobalStatement GlobalStatement() throws ParseException {
2893    final int pos = SimpleCharStream.getPosition();
2894    String expr;
2895    ArrayList vars = new ArrayList();
2896    GlobalStatement global;
2897     jj_consume_token(GLOBAL);
2898     expr = VariableDeclaratorId();
2899      vars.add(expr);
2900     label_25:
2901     while (true) {
2902       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2903       case COMMA:
2904         ;
2905         break;
2906       default:
2907         jj_la1[81] = jj_gen;
2908         break label_25;
2909       }
2910       jj_consume_token(COMMA);
2911       expr = VariableDeclaratorId();
2912      vars.add(expr);
2913     }
2914     try {
2915       jj_consume_token(SEMICOLON);
2916     String[] strings = new String[vars.size()];
2917     vars.toArray(strings);
2918     global = new GlobalStatement(currentSegment,
2919                                  strings,
2920                                  pos,
2921                                  SimpleCharStream.getPosition());
2922     currentSegment.add(global);
2923     {if (true) return global;}
2924     } catch (ParseException e) {
2925     errorMessage = "unexpected token : '"+ e.currentToken.next.image +"'. a ';' was expected";
2926     errorLevel   = ERROR;
2927     errorStart = SimpleCharStream.getPosition() - e.currentToken.next.image.length() + 1;
2928     errorEnd   = SimpleCharStream.getPosition() + 1;
2929     {if (true) throw e;}
2930     }
2931     throw new Error("Missing return statement in function");
2932   }
2933
2934   static final public StaticStatement StaticStatement() throws ParseException {
2935   final int pos = SimpleCharStream.getPosition();
2936   final ArrayList vars = new ArrayList();
2937   VariableDeclaration expr;
2938     jj_consume_token(STATIC);
2939     expr = VariableDeclarator();
2940                                         vars.add(new String(expr.name));
2941     label_26:
2942     while (true) {
2943       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2944       case COMMA:
2945         ;
2946         break;
2947       default:
2948         jj_la1[82] = jj_gen;
2949         break label_26;
2950       }
2951       jj_consume_token(COMMA);
2952       expr = VariableDeclarator();
2953                                         vars.add(new String(expr.name));
2954     }
2955     try {
2956       jj_consume_token(SEMICOLON);
2957     String[] strings = new String[vars.size()];
2958     vars.toArray(strings);
2959     {if (true) return new StaticStatement(strings,
2960                                 pos,
2961                                 SimpleCharStream.getPosition());}
2962     } catch (ParseException e) {
2963     errorMessage = "unexpected token : '"+ e.currentToken.next.image +"'. a ';' was expected";
2964     errorLevel   = ERROR;
2965     errorStart = SimpleCharStream.getPosition() - e.currentToken.next.image.length() + 1;
2966     errorEnd   = SimpleCharStream.getPosition() + 1;
2967     {if (true) throw e;}
2968     }
2969     throw new Error("Missing return statement in function");
2970   }
2971
2972   static final public LabeledStatement LabeledStatement() throws ParseException {
2973   final int pos = SimpleCharStream.getPosition();
2974   final Token label;
2975   final Statement statement;
2976     label = jj_consume_token(IDENTIFIER);
2977     jj_consume_token(COLON);
2978     statement = Statement();
2979    {if (true) return new LabeledStatement(label.image.toCharArray(),statement,pos,SimpleCharStream.getPosition());}
2980     throw new Error("Missing return statement in function");
2981   }
2982
2983 /**
2984  * A Block is
2985  * {
2986  * statements
2987  * }.
2988  * @return a block
2989  */
2990   static final public Block Block() throws ParseException {
2991   final int pos = SimpleCharStream.getPosition();
2992   final ArrayList list = new ArrayList();
2993   Statement statement;
2994     try {
2995       jj_consume_token(LBRACE);
2996     } catch (ParseException e) {
2997     errorMessage = "'{' expected";
2998     errorLevel   = ERROR;
2999     errorStart = SimpleCharStream.getPosition() - e.currentToken.next.image.length() + 1;
3000     errorEnd   = SimpleCharStream.getPosition() + 1;
3001     {if (true) throw e;}
3002     }
3003     label_27:
3004     while (true) {
3005       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3006       case PHPEND:
3007       case CLASS:
3008       case FUNCTION:
3009       case IF:
3010       case ARRAY:
3011       case BREAK:
3012       case LIST:
3013       case PRINT:
3014       case ECHO:
3015       case INCLUDE:
3016       case REQUIRE:
3017       case INCLUDE_ONCE:
3018       case REQUIRE_ONCE:
3019       case GLOBAL:
3020       case STATIC:
3021       case CONTINUE:
3022       case DO:
3023       case FOR:
3024       case NEW:
3025       case NULL:
3026       case RETURN:
3027       case SWITCH:
3028       case TRUE:
3029       case FALSE:
3030       case WHILE:
3031       case FOREACH:
3032       case AT:
3033       case DOLLAR:
3034       case BANG:
3035       case INCR:
3036       case DECR:
3037       case PLUS:
3038       case MINUS:
3039       case BIT_AND:
3040       case INTEGER_LITERAL:
3041       case FLOATING_POINT_LITERAL:
3042       case STRING_LITERAL:
3043       case IDENTIFIER:
3044       case LPAREN:
3045       case LBRACE:
3046       case SEMICOLON:
3047       case DOLLAR_ID:
3048         ;
3049         break;
3050       default:
3051         jj_la1[83] = jj_gen;
3052         break label_27;
3053       }
3054       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3055       case CLASS:
3056       case FUNCTION:
3057       case IF:
3058       case ARRAY:
3059       case BREAK:
3060       case LIST:
3061       case PRINT:
3062       case ECHO:
3063       case INCLUDE:
3064       case REQUIRE:
3065       case INCLUDE_ONCE:
3066       case REQUIRE_ONCE:
3067       case GLOBAL:
3068       case STATIC:
3069       case CONTINUE:
3070       case DO:
3071       case FOR:
3072       case NEW:
3073       case NULL:
3074       case RETURN:
3075       case SWITCH:
3076       case TRUE:
3077       case FALSE:
3078       case WHILE:
3079       case FOREACH:
3080       case AT:
3081       case DOLLAR:
3082       case BANG:
3083       case INCR:
3084       case DECR:
3085       case PLUS:
3086       case MINUS:
3087       case BIT_AND:
3088       case INTEGER_LITERAL:
3089       case FLOATING_POINT_LITERAL:
3090       case STRING_LITERAL:
3091       case IDENTIFIER:
3092       case LPAREN:
3093       case LBRACE:
3094       case SEMICOLON:
3095       case DOLLAR_ID:
3096         statement = BlockStatement();
3097                                   list.add(statement);
3098         break;
3099       case PHPEND:
3100         statement = htmlBlock();
3101                                   list.add(statement);
3102         break;
3103       default:
3104         jj_la1[84] = jj_gen;
3105         jj_consume_token(-1);
3106         throw new ParseException();
3107       }
3108     }
3109     try {
3110       jj_consume_token(RBRACE);
3111     } catch (ParseException e) {
3112     errorMessage = "unexpected token : '"+ e.currentToken.image +"', '}' expected";
3113     errorLevel   = ERROR;
3114     errorStart = SimpleCharStream.getPosition() - e.currentToken.next.image.length() + 1;
3115     errorEnd   = SimpleCharStream.getPosition() + 1;
3116     {if (true) throw e;}
3117     }
3118   Statement[] statements = new Statement[list.size()];
3119   list.toArray(statements);
3120   {if (true) return new Block(statements,pos,SimpleCharStream.getPosition());}
3121     throw new Error("Missing return statement in function");
3122   }
3123
3124   static final public Statement BlockStatement() throws ParseException {
3125   final Statement statement;
3126     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3127     case IF:
3128     case ARRAY:
3129     case BREAK:
3130     case LIST:
3131     case PRINT:
3132     case ECHO:
3133     case INCLUDE:
3134     case REQUIRE:
3135     case INCLUDE_ONCE:
3136     case REQUIRE_ONCE:
3137     case GLOBAL:
3138     case STATIC:
3139     case CONTINUE:
3140     case DO:
3141     case FOR:
3142     case NEW:
3143     case NULL:
3144     case RETURN:
3145     case SWITCH:
3146     case TRUE:
3147     case FALSE:
3148     case WHILE:
3149     case FOREACH:
3150     case AT:
3151     case DOLLAR:
3152     case BANG:
3153     case INCR:
3154     case DECR:
3155     case PLUS:
3156     case MINUS:
3157     case BIT_AND:
3158     case INTEGER_LITERAL:
3159     case FLOATING_POINT_LITERAL:
3160     case STRING_LITERAL:
3161     case IDENTIFIER:
3162     case LPAREN:
3163     case LBRACE:
3164     case SEMICOLON:
3165     case DOLLAR_ID:
3166       try {
3167         statement = Statement();
3168                                    if (phpDocument == currentSegment) pushOnAstNodes(statement);
3169                                    {if (true) return statement;}
3170       } catch (ParseException e) {
3171     if (errorMessage != null) {if (true) throw e;}
3172     errorMessage = "statement expected";
3173     errorLevel   = ERROR;
3174     errorStart = SimpleCharStream.getPosition() - e.currentToken.next.image.length() + 1;
3175     errorEnd   = SimpleCharStream.getPosition() + 1;
3176     {if (true) throw e;}
3177       }
3178       break;
3179     case CLASS:
3180       statement = ClassDeclaration();
3181                                    {if (true) return statement;}
3182       break;
3183     case FUNCTION:
3184       statement = MethodDeclaration();
3185                                    if (phpDocument == currentSegment) pushOnAstNodes(statement);
3186                                    currentSegment.add((MethodDeclaration) statement);
3187                                    {if (true) return statement;}
3188       break;
3189     default:
3190       jj_la1[85] = jj_gen;
3191       jj_consume_token(-1);
3192       throw new ParseException();
3193     }
3194     throw new Error("Missing return statement in function");
3195   }
3196
3197 /**
3198  * A Block statement that will not contain any 'break'
3199  */
3200   static final public Statement BlockStatementNoBreak() throws ParseException {
3201   final Statement statement;
3202     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3203     case IF:
3204     case ARRAY:
3205     case LIST:
3206     case PRINT:
3207     case ECHO:
3208     case INCLUDE:
3209     case REQUIRE:
3210     case INCLUDE_ONCE:
3211     case REQUIRE_ONCE:
3212     case GLOBAL:
3213     case STATIC:
3214     case CONTINUE:
3215     case DO:
3216     case FOR:
3217     case NEW:
3218     case NULL:
3219     case RETURN:
3220     case SWITCH:
3221     case TRUE:
3222     case FALSE:
3223     case WHILE:
3224     case FOREACH:
3225     case AT:
3226     case DOLLAR:
3227     case BANG:
3228     case INCR:
3229     case DECR:
3230     case PLUS:
3231     case MINUS:
3232     case BIT_AND:
3233     case INTEGER_LITERAL:
3234     case FLOATING_POINT_LITERAL:
3235     case STRING_LITERAL:
3236     case IDENTIFIER:
3237     case LPAREN:
3238     case LBRACE:
3239     case SEMICOLON:
3240     case DOLLAR_ID:
3241       statement = StatementNoBreak();
3242                                    {if (true) return statement;}
3243       break;
3244     case CLASS:
3245       statement = ClassDeclaration();
3246                                    {if (true) return statement;}
3247       break;
3248     case FUNCTION:
3249       statement = MethodDeclaration();
3250                                    currentSegment.add((MethodDeclaration) statement);
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_81() {
5034     if (jj_scan_token(INT)) 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_44() {
5040     if (jj_scan_token(ARRAY)) 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_80() {
5046     if (jj_scan_token(FLOAT)) 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_184() {
5052     if (jj_scan_token(ARRAY)) 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_79() {
5058     if (jj_scan_token(DOUBLE)) return true;
5059     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5060     return false;
5061   }
5062
5063   static final private boolean jj_3R_183() {
5064     if (jj_3R_52()) return true;
5065     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5066     return false;
5067   }
5068
5069   static final private boolean jj_3R_85() {
5070     if (jj_scan_token(LIST)) return true;
5071     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5072     if (jj_scan_token(LPAREN)) return true;
5073     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5074     Token xsp;
5075     xsp = jj_scanpos;
5076     if (jj_3R_99()) jj_scanpos = xsp;
5077     else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5078     while (true) {
5079       xsp = jj_scanpos;
5080       if (jj_3R_100()) { jj_scanpos = xsp; break; }
5081       if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5082     }
5083     if (jj_scan_token(RPAREN)) return true;
5084     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5085     xsp = jj_scanpos;
5086     if (jj_3R_101()) jj_scanpos = xsp;
5087     else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5088     return false;
5089   }
5090
5091   static final private boolean jj_3R_78() {
5092     if (jj_scan_token(REAL)) return true;
5093     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5094     return false;
5095   }
5096
5097   static final private boolean jj_3R_167() {
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_183()) {
5103     jj_scanpos = xsp;
5104     if (jj_3R_184()) 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     if (jj_3R_139()) return true;
5110     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5111     return false;
5112   }
5113
5114   static final private boolean jj_3R_77() {
5115     if (jj_scan_token(BOOLEAN)) return true;
5116     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5117     return false;
5118   }
5119
5120   static final private boolean jj_3R_76() {
5121     if (jj_scan_token(BOOL)) return true;
5122     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5123     return false;
5124   }
5125
5126   static final private boolean jj_3R_43() {
5127     if (jj_3R_52()) return true;
5128     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5129     return false;
5130   }
5131
5132   static final private boolean jj_3R_75() {
5133     if (jj_scan_token(STRING)) return true;
5134     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5135     return false;
5136   }
5137
5138   static final private boolean jj_3R_52() {
5139     Token xsp;
5140     xsp = jj_scanpos;
5141     if (jj_3R_75()) {
5142     jj_scanpos = xsp;
5143     if (jj_3R_76()) {
5144     jj_scanpos = xsp;
5145     if (jj_3R_77()) {
5146     jj_scanpos = xsp;
5147     if (jj_3R_78()) {
5148     jj_scanpos = xsp;
5149     if (jj_3R_79()) {
5150     jj_scanpos = xsp;
5151     if (jj_3R_80()) {
5152     jj_scanpos = xsp;
5153     if (jj_3R_81()) {
5154     jj_scanpos = xsp;
5155     if (jj_3R_82()) {
5156     jj_scanpos = xsp;
5157     if (jj_3R_83()) return true;
5158     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5159     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5160     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5161     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5162     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5163     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5164     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5165     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5166     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5167     return false;
5168   }
5169
5170   static final private boolean jj_3R_84() {
5171     if (jj_scan_token(PRINT)) return true;
5172     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5173     if (jj_3R_45()) return true;
5174     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5175     return false;
5176   }
5177
5178   static final private boolean jj_3_4() {
5179     if (jj_scan_token(LPAREN)) return true;
5180     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5181     Token xsp;
5182     xsp = jj_scanpos;
5183     if (jj_3R_43()) {
5184     jj_scanpos = xsp;
5185     if (jj_3R_44()) 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_scan_token(RPAREN)) 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_165() {
5194     if (jj_scan_token(LPAREN)) return true;
5195     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5196     if (jj_3R_45()) return true;
5197     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5198     if (jj_scan_token(RPAREN)) return true;
5199     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5200     return false;
5201   }
5202
5203   static final private boolean jj_3R_164() {
5204     if (jj_3R_169()) return true;
5205     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5206     return false;
5207   }
5208
5209   static final private boolean jj_3R_163() {
5210     if (jj_3R_168()) return true;
5211     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5212     return false;
5213   }
5214
5215   static final private boolean jj_3R_162() {
5216     if (jj_3R_167()) return true;
5217     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5218     return false;
5219   }
5220
5221   static final private boolean jj_3R_158() {
5222     Token xsp;
5223     xsp = jj_scanpos;
5224     if (jj_3R_161()) {
5225     jj_scanpos = xsp;
5226     if (jj_3R_162()) {
5227     jj_scanpos = xsp;
5228     if (jj_3R_163()) {
5229     jj_scanpos = xsp;
5230     if (jj_3R_164()) {
5231     jj_scanpos = xsp;
5232     if (jj_3R_165()) return true;
5233     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5234     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5235     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5236     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5237     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5238     return false;
5239   }
5240
5241   static final private boolean jj_3R_161() {
5242     if (jj_scan_token(BANG)) return true;
5243     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5244     if (jj_3R_139()) return true;
5245     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5246     return false;
5247   }
5248
5249   static final private boolean jj_3R_160() {
5250     if (jj_scan_token(DECR)) return true;
5251     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5252     return false;
5253   }
5254
5255   static final private boolean jj_3R_159() {
5256     if (jj_scan_token(INCR)) return true;
5257     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5258     return false;
5259   }
5260
5261   static final private boolean jj_3R_157() {
5262     Token xsp;
5263     xsp = jj_scanpos;
5264     if (jj_3R_159()) {
5265     jj_scanpos = xsp;
5266     if (jj_3R_160()) return true;
5267     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5268     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5269     if (jj_3R_166()) return true;
5270     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5271     return false;
5272   }
5273
5274   static final private boolean jj_3R_152() {
5275     if (jj_3R_158()) return true;
5276     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5277     return false;
5278   }
5279
5280   static final private boolean jj_3R_151() {
5281     if (jj_3R_157()) return true;
5282     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5283     return false;
5284   }
5285
5286   static final private boolean jj_3R_156() {
5287     if (jj_scan_token(MINUS)) return true;
5288     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5289     return false;
5290   }
5291
5292   static final private boolean jj_3R_155() {
5293     if (jj_scan_token(PLUS)) return true;
5294     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5295     return false;
5296   }
5297
5298   static final private boolean jj_3R_148() {
5299     Token xsp;
5300     xsp = jj_scanpos;
5301     if (jj_3R_150()) {
5302     jj_scanpos = xsp;
5303     if (jj_3R_151()) {
5304     jj_scanpos = xsp;
5305     if (jj_3R_152()) return true;
5306     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5307     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5308     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5309     return false;
5310   }
5311
5312   static final private boolean jj_3R_150() {
5313     Token xsp;
5314     xsp = jj_scanpos;
5315     if (jj_3R_155()) {
5316     jj_scanpos = xsp;
5317     if (jj_3R_156()) return true;
5318     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5319     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5320     if (jj_3R_139()) return true;
5321     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5322     return false;
5323   }
5324
5325   static final private boolean jj_3R_154() {
5326     if (jj_3R_148()) return true;
5327     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5328     return false;
5329   }
5330
5331   static final private boolean jj_3R_149() {
5332     Token xsp;
5333     xsp = jj_scanpos;
5334     if (jj_3R_153()) {
5335     jj_scanpos = xsp;
5336     if (jj_3R_154()) return true;
5337     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5338     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5339     return false;
5340   }
5341
5342   static final private boolean jj_3R_153() {
5343     if (jj_scan_token(AT)) return true;
5344     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5345     if (jj_3R_149()) return true;
5346     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5347     return false;
5348   }
5349
5350   static final private boolean jj_3R_144() {
5351     if (jj_3R_149()) return true;
5352     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5353     return false;
5354   }
5355
5356   static final private boolean jj_3R_139() {
5357     Token xsp;
5358     xsp = jj_scanpos;
5359     if (jj_3R_143()) {
5360     jj_scanpos = xsp;
5361     if (jj_3R_144()) return true;
5362     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5363     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5364     return false;
5365   }
5366
5367   static final private boolean jj_3R_143() {
5368     if (jj_scan_token(BIT_AND)) return true;
5369     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5370     if (jj_3R_148()) return true;
5371     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5372     return false;
5373   }
5374
5375   static final private boolean jj_3R_87() {
5376     if (jj_scan_token(ASSIGN)) return true;
5377     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5378     if (jj_3R_45()) return true;
5379     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5380     return false;
5381   }
5382
5383   static final private boolean jj_3R_147() {
5384     if (jj_scan_token(REMAINDER)) return true;
5385     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5386     return false;
5387   }
5388
5389   static final private boolean jj_3R_146() {
5390     if (jj_scan_token(SLASH)) return true;
5391     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5392     return false;
5393   }
5394
5395   static final private boolean jj_3R_145() {
5396     if (jj_scan_token(STAR)) 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_140() {
5402     Token xsp;
5403     xsp = jj_scanpos;
5404     if (jj_3R_145()) {
5405     jj_scanpos = xsp;
5406     if (jj_3R_146()) {
5407     jj_scanpos = xsp;
5408     if (jj_3R_147()) return true;
5409     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5410     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5411     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5412     if (jj_3R_139()) return true;
5413     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5414     return false;
5415   }
5416
5417   static final private boolean jj_3R_134() {
5418     if (jj_3R_139()) return true;
5419     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5420     Token xsp;
5421     while (true) {
5422       xsp = jj_scanpos;
5423       if (jj_3R_140()) { jj_scanpos = xsp; break; }
5424       if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5425     }
5426     return false;
5427   }
5428
5429   static final private boolean jj_3R_142() {
5430     if (jj_scan_token(MINUS)) return true;
5431     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5432     return false;
5433   }
5434
5435   static final private boolean jj_3R_141() {
5436     if (jj_scan_token(PLUS)) 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_198() {
5442     if (jj_scan_token(COMMA)) 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_57() {
5448     if (jj_3R_50()) return true;
5449     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5450     Token xsp;
5451     xsp = jj_scanpos;
5452     if (jj_3R_87()) jj_scanpos = xsp;
5453     else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5454     return false;
5455   }
5456
5457   static final private boolean jj_3R_135() {
5458     Token xsp;
5459     xsp = jj_scanpos;
5460     if (jj_3R_141()) {
5461     jj_scanpos = xsp;
5462     if (jj_3R_142()) return true;
5463     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5464     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5465     if (jj_3R_134()) return true;
5466     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5467     return false;
5468   }
5469
5470   static final private boolean jj_3_2() {
5471     if (jj_scan_token(COMMA)) return true;
5472     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5473     if (jj_3R_41()) return true;
5474     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5475     return false;
5476   }
5477
5478   static final private boolean jj_3R_128() {
5479     if (jj_3R_134()) return true;
5480     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5481     Token xsp;
5482     while (true) {
5483       xsp = jj_scanpos;
5484       if (jj_3R_135()) { jj_scanpos = xsp; break; }
5485       if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5486     }
5487     return false;
5488   }
5489
5490   static final private boolean jj_3R_197() {
5491     if (jj_3R_41()) return true;
5492     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5493     Token xsp;
5494     while (true) {
5495       xsp = jj_scanpos;
5496       if (jj_3_2()) { jj_scanpos = xsp; break; }
5497       if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5498     }
5499     return false;
5500   }
5501
5502   static final private boolean jj_3_7() {
5503     if (jj_3R_46()) return true;
5504     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5505     return false;
5506   }
5507
5508   static final private boolean jj_3R_58() {
5509     if (jj_scan_token(COMMA)) return true;
5510     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5511     if (jj_3R_57()) 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_138() {
5517     if (jj_scan_token(RUNSIGNEDSHIFT)) 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_192() {
5523     if (jj_scan_token(LPAREN)) return true;
5524     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5525     Token xsp;
5526     xsp = jj_scanpos;
5527     if (jj_3R_197()) jj_scanpos = xsp;
5528     else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5529     xsp = jj_scanpos;
5530     if (jj_3R_198()) jj_scanpos = xsp;
5531     else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5532     if (jj_scan_token(RPAREN)) return true;
5533     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5534     return false;
5535   }
5536
5537   static final private boolean jj_3R_137() {
5538     if (jj_scan_token(RSIGNEDSHIFT)) return true;
5539     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5540     return false;
5541   }
5542
5543   static final private boolean jj_3R_47() {
5544     if (jj_3R_57()) return true;
5545     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5546     Token xsp;
5547     while (true) {
5548       xsp = jj_scanpos;
5549       if (jj_3R_58()) { jj_scanpos = xsp; break; }
5550       if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5551     }
5552     return false;
5553   }
5554
5555   static final private boolean jj_3R_136() {
5556     if (jj_scan_token(LSHIFT)) return true;
5557     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5558     return false;
5559   }
5560
5561   static final private boolean jj_3R_129() {
5562     Token xsp;
5563     xsp = jj_scanpos;
5564     if (jj_3R_136()) {
5565     jj_scanpos = xsp;
5566     if (jj_3R_137()) {
5567     jj_scanpos = xsp;
5568     if (jj_3R_138()) return true;
5569     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_128()) 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_121() {
5578     if (jj_3R_128()) 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_129()) { 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_3_6() {
5590     if (jj_3R_45()) return true;
5591     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5592     if (jj_scan_token(SEMICOLON)) 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_201() {
5598     if (jj_scan_token(ARRAYASSIGN)) return true;
5599     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5600     if (jj_3R_45()) return true;
5601     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5602     return false;
5603   }
5604
5605   static final private boolean jj_3R_41() {
5606     if (jj_3R_45()) return true;
5607     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5608     Token xsp;
5609     xsp = jj_scanpos;
5610     if (jj_3R_201()) jj_scanpos = xsp;
5611     else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5612     return false;
5613   }
5614
5615   static final private boolean jj_3R_133() {
5616     if (jj_scan_token(GE)) 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_132() {
5622     if (jj_scan_token(LE)) 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_131() {
5628     if (jj_scan_token(GT)) 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_130() {
5634     if (jj_scan_token(LT)) 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_122() {
5640     Token xsp;
5641     xsp = jj_scanpos;
5642     if (jj_3R_130()) {
5643     jj_scanpos = xsp;
5644     if (jj_3R_131()) {
5645     jj_scanpos = xsp;
5646     if (jj_3R_132()) {
5647     jj_scanpos = xsp;
5648     if (jj_3R_133()) return true;
5649     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5650     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5651     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5652     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5653     if (jj_3R_121()) return true;
5654     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5655     return false;
5656   }
5657
5658   static final private boolean jj_3R_119() {
5659     if (jj_3R_121()) return true;
5660     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5661     Token xsp;
5662     while (true) {
5663       xsp = jj_scanpos;
5664       if (jj_3R_122()) { jj_scanpos = xsp; break; }
5665       if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5666     }
5667     return false;
5668   }
5669
5670   static final private boolean jj_3R_203() {
5671     if (jj_scan_token(COMMA)) return true;
5672     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5673     if (jj_3R_45()) return true;
5674     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5675     return false;
5676   }
5677
5678   static final private boolean jj_3R_202() {
5679     if (jj_3R_45()) return true;
5680     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5681     Token xsp;
5682     while (true) {
5683       xsp = jj_scanpos;
5684       if (jj_3R_203()) { jj_scanpos = xsp; break; }
5685       if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5686     }
5687     return false;
5688   }
5689
5690   static final private boolean jj_3R_127() {
5691     if (jj_scan_token(TRIPLEEQUAL)) return true;
5692     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5693     return false;
5694   }
5695
5696   static final private boolean jj_3R_200() {
5697     if (jj_3R_202()) return true;
5698     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5699     return false;
5700   }
5701
5702   static final private boolean jj_3R_126() {
5703     if (jj_scan_token(BANGDOUBLEEQUAL)) return true;
5704     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5705     return false;
5706   }
5707
5708   static final private boolean jj_3R_125() {
5709     if (jj_scan_token(NOT_EQUAL)) return true;
5710     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5711     return false;
5712   }
5713
5714   static final private boolean jj_3R_108() {
5715     if (jj_scan_token(LBRACE)) return true;
5716     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5717     if (jj_3R_45()) return true;
5718     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5719     if (jj_scan_token(RBRACE)) return true;
5720     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5721     return false;
5722   }
5723
5724   static final private boolean jj_3R_124() {
5725     if (jj_scan_token(DIF)) return true;
5726     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5727     return false;
5728   }
5729
5730   static final private boolean jj_3R_123() {
5731     if (jj_scan_token(EQUAL_EQUAL)) return true;
5732     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5733     return false;
5734   }
5735
5736   static final private boolean jj_3R_91() {
5737     if (jj_scan_token(DOLLAR_ID)) return true;
5738     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5739     return false;
5740   }
5741
5742   static final private boolean jj_3R_120() {
5743     Token xsp;
5744     xsp = jj_scanpos;
5745     if (jj_3R_123()) {
5746     jj_scanpos = xsp;
5747     if (jj_3R_124()) {
5748     jj_scanpos = xsp;
5749     if (jj_3R_125()) {
5750     jj_scanpos = xsp;
5751     if (jj_3R_126()) {
5752     jj_scanpos = xsp;
5753     if (jj_3R_127()) return true;
5754     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5755     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5756     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5757     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5758     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5759     if (jj_3R_119()) return true;
5760     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5761     return false;
5762   }
5763
5764   static final private boolean jj_3R_93() {
5765     if (jj_3R_52()) return true;
5766     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5767     return false;
5768   }
5769
5770   static final private boolean jj_3R_117() {
5771     if (jj_3R_119()) return true;
5772     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5773     Token xsp;
5774     while (true) {
5775       xsp = jj_scanpos;
5776       if (jj_3R_120()) { jj_scanpos = xsp; break; }
5777       if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5778     }
5779     return false;
5780   }
5781
5782   static final private boolean jj_3R_199() {
5783     if (jj_scan_token(LPAREN)) return true;
5784     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5785     Token xsp;
5786     xsp = jj_scanpos;
5787     if (jj_3R_200()) jj_scanpos = xsp;
5788     else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5789     if (jj_scan_token(RPAREN)) return true;
5790     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5791     return false;
5792   }
5793
5794   static final private boolean jj_3R_90() {
5795     if (jj_scan_token(DOLLAR)) return true;
5796     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5797     if (jj_3R_59()) return true;
5798     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5799     return false;
5800   }
5801
5802   static final private boolean jj_3R_118() {
5803     if (jj_scan_token(BIT_AND)) return true;
5804     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5805     if (jj_3R_117()) return true;
5806     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5807     return false;
5808   }
5809
5810   static final private boolean jj_3R_177() {
5811     if (jj_scan_token(NULL)) return true;
5812     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5813     return false;
5814   }
5815
5816   static final private boolean jj_3R_176() {
5817     if (jj_scan_token(FALSE)) return true;
5818     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5819     return false;
5820   }
5821
5822   static final private boolean jj_3R_115() {
5823     if (jj_3R_117()) return true;
5824     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5825     Token xsp;
5826     while (true) {
5827       xsp = jj_scanpos;
5828       if (jj_3R_118()) { jj_scanpos = xsp; break; }
5829       if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5830     }
5831     return false;
5832   }
5833
5834   static final private boolean jj_3R_175() {
5835     if (jj_scan_token(TRUE)) return true;
5836     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5837     return false;
5838   }
5839
5840   static final private boolean jj_3R_89() {
5841     if (jj_scan_token(IDENTIFIER)) return true;
5842     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5843     Token xsp;
5844     xsp = jj_scanpos;
5845     if (jj_3R_108()) jj_scanpos = xsp;
5846     else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5847     return false;
5848   }
5849
5850   static final private boolean jj_3R_174() {
5851     if (jj_scan_token(STRING_LITERAL)) return true;
5852     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5853     return false;
5854   }
5855
5856   static final private boolean jj_3R_173() {
5857     if (jj_scan_token(FLOATING_POINT_LITERAL)) return true;
5858     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5859     return false;
5860   }
5861
5862   static final private boolean jj_3R_88() {
5863     if (jj_scan_token(LBRACE)) return true;
5864     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5865     if (jj_3R_45()) return true;
5866     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5867     if (jj_scan_token(RBRACE)) return true;
5868     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5869     return false;
5870   }
5871
5872   static final private boolean jj_3R_59() {
5873     Token xsp;
5874     xsp = jj_scanpos;
5875     if (jj_3R_88()) {
5876     jj_scanpos = xsp;
5877     if (jj_3R_89()) {
5878     jj_scanpos = xsp;
5879     if (jj_3R_90()) {
5880     jj_scanpos = xsp;
5881     if (jj_3R_91()) return true;
5882     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5883     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5884     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5885     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5886     return false;
5887   }
5888
5889   static final private boolean jj_3R_169() {
5890     Token xsp;
5891     xsp = jj_scanpos;
5892     if (jj_3R_172()) {
5893     jj_scanpos = xsp;
5894     if (jj_3R_173()) {
5895     jj_scanpos = xsp;
5896     if (jj_3R_174()) {
5897     jj_scanpos = xsp;
5898     if (jj_3R_175()) {
5899     jj_scanpos = xsp;
5900     if (jj_3R_176()) {
5901     jj_scanpos = xsp;
5902     if (jj_3R_177()) return true;
5903     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5904     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5905     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5906     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5907     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5908     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5909     return false;
5910   }
5911
5912   static final private boolean jj_3R_172() {
5913     if (jj_scan_token(INTEGER_LITERAL)) return true;
5914     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5915     return false;
5916   }
5917
5918   static final private boolean jj_3R_116() {
5919     if (jj_scan_token(XOR)) return true;
5920     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5921     if (jj_3R_115()) return true;
5922     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5923     return false;
5924   }
5925
5926   static final private boolean jj_3R_113() {
5927     if (jj_3R_115()) return true;
5928     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5929     Token xsp;
5930     while (true) {
5931       xsp = jj_scanpos;
5932       if (jj_3R_116()) { jj_scanpos = xsp; break; }
5933       if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5934     }
5935     return false;
5936   }
5937
5938   static final private boolean jj_3R_92() {
5939     if (jj_3R_45()) return true;
5940     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5941     return false;
5942   }
5943
5944   static final private boolean jj_3R_60() {
5945     Token xsp;
5946     xsp = jj_scanpos;
5947     if (jj_3R_92()) {
5948     jj_scanpos = xsp;
5949     if (jj_3R_93()) return true;
5950     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5951     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5952     return false;
5953   }
5954
5955   static final private boolean jj_3_8() {
5956     if (jj_3R_47()) return true;
5957     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5958     return false;
5959   }
5960
5961   static final private boolean jj_3R_98() {
5962     if (jj_scan_token(LBRACE)) return true;
5963     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5964     if (jj_3R_45()) return true;
5965     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5966     if (jj_scan_token(RBRACE)) return true;
5967     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5968     return false;
5969   }
5970
5971   static final private boolean jj_3R_46() {
5972     if (jj_scan_token(IDENTIFIER)) return true;
5973     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5974     if (jj_scan_token(COLON)) return true;
5975     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5976     return false;
5977   }
5978
5979   static final private boolean jj_3R_95() {
5980     if (jj_scan_token(DOLLAR)) 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_114() {
5988     if (jj_scan_token(BIT_OR)) return true;
5989     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5990     if (jj_3R_113()) return true;
5991     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5992     return false;
5993   }
5994
5995   static final private boolean jj_3R_109() {
5996     if (jj_3R_113()) return true;
5997     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5998     Token xsp;
5999     while (true) {
6000       xsp = jj_scanpos;
6001       if (jj_3R_114()) { jj_scanpos = xsp; break; }
6002       if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6003     }
6004     return false;
6005   }
6006
6007   static final private boolean jj_3R_49() {
6008     if (jj_scan_token(LBRACKET)) return true;
6009     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6010     Token xsp;
6011     xsp = jj_scanpos;
6012     if (jj_3R_60()) jj_scanpos = xsp;
6013     else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6014     if (jj_scan_token(RBRACKET)) return true;
6015     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6016     return false;
6017   }
6018
6019   static final private boolean jj_3R_110() {
6020     if (jj_scan_token(DOT)) return true;
6021     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6022     if (jj_3R_109()) return true;
6023     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6024     return false;
6025   }
6026
6027   static final private boolean jj_3R_94() {
6028     if (jj_scan_token(DOLLAR_ID)) return true;
6029     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6030     Token xsp;
6031     xsp = jj_scanpos;
6032     if (jj_3R_98()) jj_scanpos = xsp;
6033     else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6034     return false;
6035   }
6036
6037   static final private boolean jj_3R_61() {
6038     Token xsp;
6039     xsp = jj_scanpos;
6040     if (jj_3R_94()) {
6041     jj_scanpos = xsp;
6042     if (jj_3R_95()) return true;
6043     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6044     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6045     return false;
6046   }
6047
6048   static final private boolean jj_3R_104() {
6049     if (jj_3R_109()) return true;
6050     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6051     Token xsp;
6052     while (true) {
6053       xsp = jj_scanpos;
6054       if (jj_3R_110()) { jj_scanpos = xsp; break; }
6055       if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6056     }
6057     return false;
6058   }
6059
6060   static final private boolean jj_3R_48() {
6061     if (jj_scan_token(CLASSACCESS)) return true;
6062     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6063     if (jj_3R_59()) return true;
6064     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6065     return false;
6066   }
6067
6068   static final private boolean jj_3R_40() {
6069     Token xsp;
6070     xsp = jj_scanpos;
6071     if (jj_3R_48()) {
6072     jj_scanpos = xsp;
6073     if (jj_3R_49()) return true;
6074     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6075     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6076     return false;
6077   }
6078
6079   static final private boolean jj_3R_112() {
6080     if (jj_scan_token(_ANDL)) return true;
6081     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6082     return false;
6083   }
6084
6085   static final private boolean jj_3R_111() {
6086     if (jj_scan_token(AND_AND)) return true;
6087     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6088     return false;
6089   }
6090
6091   static final private boolean jj_3R_196() {
6092     if (jj_3R_40()) return true;
6093     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6094     return false;
6095   }
6096
6097   static final private boolean jj_3R_105() {
6098     Token xsp;
6099     xsp = jj_scanpos;
6100     if (jj_3R_111()) {
6101     jj_scanpos = xsp;
6102     if (jj_3R_112()) return true;
6103     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6104     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6105     if (jj_3R_104()) return true;
6106     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6107     return false;
6108   }
6109
6110   static final private boolean jj_3R_195() {
6111     if (jj_3R_199()) return true;
6112     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6113     return false;
6114   }
6115
6116   static final private boolean jj_3R_188() {
6117     Token xsp;
6118     xsp = jj_scanpos;
6119     if (jj_3R_195()) {
6120     jj_scanpos = xsp;
6121     if (jj_3R_196()) return true;
6122     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6123     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6124     return false;
6125   }
6126
6127   static final private boolean jj_3R_97() {
6128     if (jj_scan_token(HOOK)) return true;
6129     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6130     if (jj_3R_45()) return true;
6131     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6132     if (jj_scan_token(COLON)) return true;
6133     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6134     if (jj_3R_86()) return true;
6135     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6136     return false;
6137   }
6138
6139   static final private boolean jj_3R_102() {
6140     if (jj_3R_104()) return true;
6141     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6142     Token xsp;
6143     while (true) {
6144       xsp = jj_scanpos;
6145       if (jj_3R_105()) { jj_scanpos = xsp; break; }
6146       if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6147     }
6148     return false;
6149   }
6150
6151   static final private boolean jj_3R_187() {
6152     if (jj_3R_50()) return true;
6153     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6154     return false;
6155   }
6156
6157   static final private boolean jj_3R_107() {
6158     if (jj_scan_token(_ORL)) return true;
6159     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6160     return false;
6161   }
6162
6163   static final private boolean jj_3R_106() {
6164     if (jj_scan_token(OR_OR)) return true;
6165     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6166     return false;
6167   }
6168
6169   static final private boolean jj_3R_186() {
6170     if (jj_scan_token(IDENTIFIER)) return true;
6171     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6172     return false;
6173   }
6174
6175   static final private boolean jj_3R_178() {
6176     Token xsp;
6177     xsp = jj_scanpos;
6178     if (jj_3R_186()) {
6179     jj_scanpos = xsp;
6180     if (jj_3R_187()) return true;
6181     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6182     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6183     return false;
6184   }
6185
6186   static final private boolean jj_3_1() {
6187     if (jj_3R_40()) return true;
6188     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6189     return false;
6190   }
6191
6192   static final private boolean jj_3R_103() {
6193     Token xsp;
6194     xsp = jj_scanpos;
6195     if (jj_3R_106()) {
6196     jj_scanpos = xsp;
6197     if (jj_3R_107()) return true;
6198     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6199     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6200     if (jj_3R_102()) return true;
6201     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6202     return false;
6203   }
6204
6205   static final private boolean jj_3R_50() {
6206     if (jj_3R_61()) return true;
6207     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6208     Token xsp;
6209     while (true) {
6210       xsp = jj_scanpos;
6211       if (jj_3_1()) { jj_scanpos = xsp; break; }
6212       if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6213     }
6214     return false;
6215   }
6216
6217   static final private boolean jj_3R_96() {
6218     if (jj_3R_102()) return true;
6219     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6220     Token xsp;
6221     while (true) {
6222       xsp = jj_scanpos;
6223       if (jj_3R_103()) { jj_scanpos = xsp; break; }
6224       if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6225     }
6226     return false;
6227   }
6228
6229   static final private boolean jj_3R_86() {
6230     if (jj_3R_96()) return true;
6231     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6232     Token xsp;
6233     xsp = jj_scanpos;
6234     if (jj_3R_97()) jj_scanpos = xsp;
6235     else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6236     return false;
6237   }
6238
6239   static final private boolean jj_3R_74() {
6240     if (jj_scan_token(TILDEEQUAL)) return true;
6241     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6242     return false;
6243   }
6244
6245   static final private boolean jj_3R_191() {
6246     if (jj_3R_50()) return true;
6247     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6248     return false;
6249   }
6250
6251   static final private boolean jj_3R_73() {
6252     if (jj_scan_token(DOTASSIGN)) return true;
6253     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6254     return false;
6255   }
6256
6257   static final private boolean jj_3R_72() {
6258     if (jj_scan_token(ORASSIGN)) return true;
6259     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6260     return false;
6261   }
6262
6263   static final private boolean jj_3R_71() {
6264     if (jj_scan_token(XORASSIGN)) return true;
6265     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6266     return false;
6267   }
6268
6269   static final private boolean jj_3R_190() {
6270     if (jj_scan_token(NEW)) return true;
6271     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6272     if (jj_3R_178()) return true;
6273     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6274     return false;
6275   }
6276
6277   static final private boolean jj_3R_70() {
6278     if (jj_scan_token(ANDASSIGN)) return true;
6279     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6280     return false;
6281   }
6282
6283   static final private boolean jj_3R_69() {
6284     if (jj_scan_token(RSIGNEDSHIFTASSIGN)) return true;
6285     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6286     return false;
6287   }
6288
6289   static final private boolean jj_3R_68() {
6290     if (jj_scan_token(LSHIFTASSIGN)) return true;
6291     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6292     return false;
6293   }
6294
6295   static final private boolean jj_3R_189() {
6296     if (jj_scan_token(IDENTIFIER)) return true;
6297     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6298     return false;
6299   }
6300
6301   static final private boolean jj_3R_180() {
6302     Token xsp;
6303     xsp = jj_scanpos;
6304     if (jj_3R_189()) {
6305     jj_scanpos = xsp;
6306     if (jj_3R_190()) {
6307     jj_scanpos = xsp;
6308     if (jj_3R_191()) return true;
6309     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6310     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6311     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6312     return false;
6313   }
6314
6315   static final private boolean jj_3R_67() {
6316     if (jj_scan_token(MINUSASSIGN)) return true;
6317     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6318     return false;
6319   }
6320
6321   static final private boolean jj_3R_66() {
6322     if (jj_scan_token(PLUSASSIGN)) return true;
6323     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6324     return false;
6325   }
6326
6327   static final private boolean jj_3R_65() {
6328     if (jj_scan_token(REMASSIGN)) return true;
6329     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6330     return false;
6331   }
6332
6333   static final private boolean jj_3R_64() {
6334     if (jj_scan_token(SLASHASSIGN)) return true;
6335     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6336     return false;
6337   }
6338
6339   static final private boolean jj_3R_63() {
6340     if (jj_scan_token(STARASSIGN)) return true;
6341     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6342     return false;
6343   }
6344
6345   static final private boolean jj_3R_51() {
6346     Token xsp;
6347     xsp = jj_scanpos;
6348     if (jj_3R_62()) {
6349     jj_scanpos = xsp;
6350     if (jj_3R_63()) {
6351     jj_scanpos = xsp;
6352     if (jj_3R_64()) {
6353     jj_scanpos = xsp;
6354     if (jj_3R_65()) {
6355     jj_scanpos = xsp;
6356     if (jj_3R_66()) {
6357     jj_scanpos = xsp;
6358     if (jj_3R_67()) {
6359     jj_scanpos = xsp;
6360     if (jj_3R_68()) {
6361     jj_scanpos = xsp;
6362     if (jj_3R_69()) {
6363     jj_scanpos = xsp;
6364     if (jj_3R_70()) {
6365     jj_scanpos = xsp;
6366     if (jj_3R_71()) {
6367     jj_scanpos = xsp;
6368     if (jj_3R_72()) {
6369     jj_scanpos = xsp;
6370     if (jj_3R_73()) {
6371     jj_scanpos = xsp;
6372     if (jj_3R_74()) return true;
6373     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6374     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6375     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6376     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6377     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6378     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6379     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6380     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6381     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6382     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6383     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6384     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6385     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6386     return false;
6387   }
6388
6389   static final private boolean jj_3R_62() {
6390     if (jj_scan_token(ASSIGN)) return true;
6391     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6392     return false;
6393   }
6394
6395   static final private boolean jj_3R_182() {
6396     if (jj_scan_token(ARRAY)) return true;
6397     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6398     if (jj_3R_192()) return true;
6399     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6400     return false;
6401   }
6402
6403   static final private boolean jj_3R_171() {
6404     if (jj_3R_182()) return true;
6405     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6406     return false;
6407   }
6408
6409   static final private boolean jj_3R_181() {
6410     if (jj_3R_188()) return true;
6411     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6412     return false;
6413   }
6414
6415   static final private boolean jj_3R_170() {
6416     if (jj_3R_180()) return true;
6417     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6418     Token xsp;
6419     while (true) {
6420       xsp = jj_scanpos;
6421       if (jj_3R_181()) { jj_scanpos = xsp; break; }
6422       if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6423     }
6424     return false;
6425   }
6426
6427   static final private boolean jj_3R_101() {
6428     if (jj_scan_token(ASSIGN)) return true;
6429     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6430     if (jj_3R_45()) return true;
6431     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6432     return false;
6433   }
6434
6435   static final private boolean jj_3R_179() {
6436     if (jj_3R_188()) return true;
6437     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6438     return false;
6439   }
6440
6441   static final private boolean jj_3R_42() {
6442     if (jj_3R_50()) return true;
6443     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6444     if (jj_3R_51()) return true;
6445     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6446     if (jj_3R_45()) return true;
6447     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6448     return false;
6449   }
6450
6451   static final private boolean jj_3_3() {
6452     if (jj_3R_42()) return true;
6453     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6454     return false;
6455   }
6456
6457   static final private boolean jj_3_5() {
6458     if (jj_scan_token(IDENTIFIER)) return true;
6459     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6460     if (jj_scan_token(STATICCLASSACCESS)) return true;
6461     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6462     if (jj_3R_178()) return true;
6463     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6464     Token xsp;
6465     while (true) {
6466       xsp = jj_scanpos;
6467       if (jj_3R_179()) { jj_scanpos = xsp; break; }
6468       if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6469     }
6470     return false;
6471   }
6472
6473   static final private boolean jj_3R_166() {
6474     Token xsp;
6475     xsp = jj_scanpos;
6476     if (jj_3_5()) {
6477     jj_scanpos = xsp;
6478     if (jj_3R_170()) {
6479     jj_scanpos = xsp;
6480     if (jj_3R_171()) return true;
6481     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6482     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6483     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6484     return false;
6485   }
6486
6487   static final private boolean jj_3R_56() {
6488     if (jj_3R_86()) return true;
6489     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6490     return false;
6491   }
6492
6493   static final private boolean jj_3R_55() {
6494     if (jj_3R_42()) return true;
6495     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6496     return false;
6497   }
6498
6499   static final private boolean jj_3R_54() {
6500     if (jj_3R_85()) return true;
6501     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6502     return false;
6503   }
6504
6505   static final private boolean jj_3R_45() {
6506     Token xsp;
6507     xsp = jj_scanpos;
6508     if (jj_3R_53()) {
6509     jj_scanpos = xsp;
6510     if (jj_3R_54()) {
6511     jj_scanpos = xsp;
6512     if (jj_3R_55()) {
6513     jj_scanpos = xsp;
6514     if (jj_3R_56()) return true;
6515     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6516     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6517     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6518     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6519     return false;
6520   }
6521
6522   static final private boolean jj_3R_53() {
6523     if (jj_3R_84()) return true;
6524     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6525     return false;
6526   }
6527
6528   static final private boolean jj_3R_100() {
6529     if (jj_scan_token(COMMA)) return true;
6530     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6531     if (jj_3R_50()) 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_194() {
6537     if (jj_scan_token(DECR)) 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_193() {
6543     if (jj_scan_token(INCR)) return true;
6544     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6545     return false;
6546   }
6547
6548   static final private boolean jj_3R_185() {
6549     Token xsp;
6550     xsp = jj_scanpos;
6551     if (jj_3R_193()) {
6552     jj_scanpos = xsp;
6553     if (jj_3R_194()) return true;
6554     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6555     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6556     return false;
6557   }
6558
6559   static final private boolean jj_3R_99() {
6560     if (jj_3R_50()) return true;
6561     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6562     return false;
6563   }
6564
6565   static final private boolean jj_3R_168() {
6566     if (jj_3R_166()) return true;
6567     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6568     Token xsp;
6569     xsp = jj_scanpos;
6570     if (jj_3R_185()) jj_scanpos = xsp;
6571     else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6572     return false;
6573   }
6574
6575   static final private boolean jj_3R_83() {
6576     if (jj_scan_token(OBJECT)) return true;
6577     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6578     return false;
6579   }
6580
6581   static final private boolean jj_3R_82() {
6582     if (jj_scan_token(INTEGER)) 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[] {0xf960001e,0x6,0x6,0xf960001e,0x0,0xf9600000,0x0,0xc00000,0xc00000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x8000000,0x0,0x68000000,0x0,0x0,0x0,0x0,0x0,0x0,0x60000000,0x8000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x8000000,0x8000000,0x0,0x8000000,0x0,0x0,0x8000000,0x8000000,0x0,0x0,0x0,0x0,0x8000000,0x0,0x8000000,0x0,0x0,0x68000000,0x68000000,0x0,0x0,0x68000000,0x0,0x0,0x89000000,0xf9000000,0x8,0x6,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xf9600010,0xf9600010,0xf9600000,0xe9600000,0x0,0x0,0x0,0x0,0x8000000,0x0,0x0,0x0,0xe9600010,0xe9600010,0x10000000,0x0,0x68000000,0xf9000010,0xf9000010,0x2000000,0x4000000,0xf9000010,0x2000000,0x4000000,0xf9000010,0xf9000010,0xf9000010,0xf9000010,0xf9000010,0xf9000000,0xf9000000,0x8000000,0x68000000,0x8000000,0xf9000000,0xf9000000,0x8000000,0x0,0x68000000,0x68000000,};
6612    }
6613    private static void jj_la1_1() {
6614       jj_la1_1 = new int[] {0x43aea83f,0x0,0x0,0x43aea83f,0x0,0x43aea83f,0x4000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1840000,0x100,0x1860000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1860000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1860000,0x1860000,0x0,0x1860000,0x0,0x0,0x1860000,0x0,0x0,0x0,0x40,0x40,0x20000,0x20000,0x20000,0x0,0x40,0x1860000,0x1860000,0x40,0x1840000,0x1860000,0x0,0x0,0x422aa83f,0x43aea83f,0x0,0x0,0xf,0x0,0x0,0x0,0x0,0x0,0x0,0x43aea83f,0x43aea83f,0x43aea83f,0x43aea83f,0x0,0x0,0x0,0x0,0x20000,0x0,0x1200,0x1200,0x43aea83f,0x43aea83f,0x0,0x1200,0x1860000,0x43aea83f,0x43aea83f,0x0,0x0,0x43aea83f,0x0,0x0,0x43aea83f,0x43aea83f,0x43aea83f,0x43aea83f,0x43aea83f,0x43aea83f,0x43aea83f,0x20000,0x1860000,0x20000,0x43aea83f,0x43aea83f,0x20000,0x0,0x1860000,0x1860000,};
6615    }
6616    private static void jj_la1_2() {
6617       jj_la1_2 = new int[] {0x9e0e00,0x0,0x0,0x9e0e00,0x0,0x9e0e00,0x0,0x0,0x0,0x0,0x0,0x0,0x400,0x0,0x400,0x0,0x0,0x180000,0x0,0x9e0e00,0x0,0x800000,0x0,0x800400,0x800000,0x1ff,0x0,0x9e0e00,0x0,0x2000,0x40008000,0x40008000,0x80010000,0x80010000,0x0,0x1000000,0x2000000,0x800000,0x0,0x0,0x0,0x0,0x38000000,0x38000000,0x180000,0x180000,0x4600000,0x4600000,0x9e0e00,0x1e0e00,0x180000,0x1e0c00,0x60000,0x800,0x400,0x1ff,0x60000,0x60000,0x0,0x0,0x400,0x400,0x400,0x400,0x0,0x9e0fff,0x9e0fff,0x0,0x0,0x9e0e00,0x0,0x200,0x60600,0x9e0e00,0x0,0x0,0x0,0x400,0x0,0x0,0x0,0x0,0x0,0x9e0e00,0x9e0e00,0x9e0e00,0x9e0e00,0x0,0x0,0x60000,0x60000,0x60400,0x4000,0x0,0x0,0x9e0e00,0x9e0e00,0x0,0x0,0x9e0e00,0x9e0e00,0x9e0e00,0x0,0x0,0x9e0e00,0x0,0x0,0x9e4e00,0x9e0e00,0x9e0e00,0x9e0e00,0x9e0e00,0x9e0e00,0x9e4e00,0x60400,0x9e0e00,0x60400,0x9e0e00,0x9e4e00,0x60400,0x0,0x9e0e00,0x9e0e00,};
6618    }
6619    private static void jj_la1_3() {
6620       jj_la1_3 = new int[] {0x114451,0x0,0x0,0x114451,0x100000,0x114451,0x0,0x0,0x0,0x200000,0x0,0x10000,0x0,0x10000,0x10400,0x11,0x11,0x451,0x0,0x4451,0x200000,0x0,0x200000,0x0,0x0,0x0,0x0,0x4451,0x0,0x0,0x0,0x0,0x0,0x0,0x400000,0x0,0x0,0x0,0xf2000000,0xf2000000,0xd800000,0xd800000,0x0,0x0,0x0,0x0,0x0,0x0,0x4451,0x4451,0x0,0x4451,0x0,0x0,0x4451,0x0,0x0,0x0,0x44000,0x44000,0x400,0x400,0x400,0x400,0x44000,0x4451,0x4451,0x40000,0x51,0x4451,0x200000,0x0,0x110400,0x114451,0x0,0x0,0x0,0x0,0x200000,0x0,0x200000,0x200000,0x200000,0x114451,0x114451,0x114451,0x114451,0x200000,0x0,0x0,0x0,0x400,0x10000,0x0,0x0,0x114451,0x114451,0x0,0x0,0x4451,0x114451,0x114451,0x0,0x0,0x114451,0x0,0x0,0x114451,0x114451,0x114451,0x114451,0x114451,0x114451,0x114451,0x400,0x4451,0x400,0x114451,0x114451,0x400,0x200000,0x4451,0x4451,};
6621    }
6622    private static void jj_la1_4() {
6623       jj_la1_4 = new int[] {0x2000,0x0,0x0,0x2000,0x0,0x2000,0x0,0x0,0x0,0x0,0x1,0x0,0x2000,0x0,0x2000,0x0,0x0,0x0,0x0,0x2000,0x0,0x0,0x0,0x2000,0x0,0x0,0x0,0x2000,0x1fff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x2000,0x2000,0x0,0x2000,0x0,0x0,0x2000,0x0,0x0,0x0,0x0,0x0,0x2000,0x2000,0x2000,0x2000,0x0,0x2000,0x2000,0x0,0x0,0x2000,0x0,0x0,0x2000,0x2000,0x0,0x0,0x0,0x2000,0x0,0x1,0x0,0x0,0x0,0x2000,0x2000,0x2000,0x2000,0x0,0x1,0x1fff,0x1fff,0x2000,0x0,0x0,0x0,0x2000,0x2000,0x0,0x0,0x2000,0x2000,0x2000,0x0,0x0,0x2000,0x0,0x0,0x2000,0x2000,0x2000,0x2000,0x2000,0x2000,0x2000,0x2000,0x2000,0x2000,0x2000,0x2000,0x2000,0x0,0x2000,0x2000,};
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[142];
6812     for (int i = 0; i < 142; 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 < 142; 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 }