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