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