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