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