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