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