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

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