net.sourceforge.phpeclipse/src/test/PHPParser.java

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