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