net.sourceforge.phpeclipse/src/test/PHPParser.java

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