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