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