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 }