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