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