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