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       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     {if (true) throw 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 - 1;
2689   blockNodes = new AstNode[nbNodes];
2690   System.arraycopy(nodes,startIndex,blockNodes,0,nbNodes);
2691   {if (true) return new HTMLBlock(nodes);}
2692     throw new Error("Missing return statement in function");
2693   }
2694
2695 /**
2696  * An include statement. It's "include" an expression;
2697  */
2698   static final public InclusionStatement IncludeStatement() throws ParseException {
2699   final Expression expr;
2700   final int keyword;
2701   final int pos = SimpleCharStream.getPosition();
2702   final InclusionStatement inclusionStatement;
2703     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2704     case REQUIRE:
2705       jj_consume_token(REQUIRE);
2706                          keyword = InclusionStatement.REQUIRE;
2707       break;
2708     case REQUIRE_ONCE:
2709       jj_consume_token(REQUIRE_ONCE);
2710                          keyword = InclusionStatement.REQUIRE_ONCE;
2711       break;
2712     case INCLUDE:
2713       jj_consume_token(INCLUDE);
2714                          keyword = InclusionStatement.INCLUDE;
2715       break;
2716     case INCLUDE_ONCE:
2717       jj_consume_token(INCLUDE_ONCE);
2718                          keyword = InclusionStatement.INCLUDE_ONCE;
2719       break;
2720     default:
2721       jj_la1[76] = jj_gen;
2722       jj_consume_token(-1);
2723       throw new ParseException();
2724     }
2725     try {
2726       expr = Expression();
2727     } catch (ParseException e) {
2728     if (errorMessage != null) {
2729       {if (true) throw e;}
2730     }
2731     errorMessage = "unexpected token '"+ e.currentToken.next.image+"', expression expected";
2732     errorLevel   = ERROR;
2733     errorStart   = SimpleCharStream.getPosition() - e.currentToken.next.image.length() + 1;
2734     errorEnd     = SimpleCharStream.getPosition() + 1;
2735     {if (true) throw e;}
2736     }
2737    inclusionStatement = new InclusionStatement(currentSegment,
2738                                                keyword,
2739                                                expr,
2740                                                pos);
2741    currentSegment.add(inclusionStatement);
2742     try {
2743       jj_consume_token(SEMICOLON);
2744     } catch (ParseException e) {
2745     errorMessage = "unexpected token : '"+ e.currentToken.next.image +"'. A ';' was expected";
2746     errorLevel   = ERROR;
2747     errorStart   = SimpleCharStream.getPosition() - e.currentToken.next.image.length() + 1;
2748     errorEnd     = SimpleCharStream.getPosition() + 1;
2749     {if (true) throw e;}
2750     }
2751    {if (true) return inclusionStatement;}
2752     throw new Error("Missing return statement in function");
2753   }
2754
2755   static final public PrintExpression PrintExpression() throws ParseException {
2756   final Expression expr;
2757   final int pos = SimpleCharStream.getPosition();
2758     jj_consume_token(PRINT);
2759     expr = Expression();
2760                                {if (true) return new PrintExpression(expr,pos,SimpleCharStream.getPosition());}
2761     throw new Error("Missing return statement in function");
2762   }
2763
2764   static final public ListExpression ListExpression() throws ParseException {
2765   String expr = null;
2766   Expression expression = null;
2767   ArrayList list = new ArrayList();
2768   final int pos = SimpleCharStream.getPosition();
2769     jj_consume_token(LIST);
2770     try {
2771       jj_consume_token(LPAREN);
2772     } catch (ParseException e) {
2773     errorMessage = "unexpected token : '"+ e.currentToken.next.image +"', '(' expected";
2774     errorLevel   = ERROR;
2775     errorStart   = SimpleCharStream.getPosition() - e.currentToken.next.image.length() + 1;
2776     errorEnd     = SimpleCharStream.getPosition() + 1;
2777     {if (true) throw e;}
2778     }
2779     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2780     case DOLLAR:
2781     case DOLLAR_ID:
2782       expr = VariableDeclaratorId();
2783      list.add(expr);
2784       break;
2785     default:
2786       jj_la1[77] = jj_gen;
2787       ;
2788     }
2789    if (expr == null) list.add(null);
2790     label_23:
2791     while (true) {
2792       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2793       case COMMA:
2794         ;
2795         break;
2796       default:
2797         jj_la1[78] = jj_gen;
2798         break label_23;
2799       }
2800       try {
2801         jj_consume_token(COMMA);
2802       } catch (ParseException e) {
2803       errorMessage = "unexpected token : '"+ e.currentToken.next.image +"', ',' expected";
2804       errorLevel   = ERROR;
2805       errorStart   = SimpleCharStream.getPosition() - e.currentToken.next.image.length() + 1;
2806       errorEnd     = SimpleCharStream.getPosition() + 1;
2807       {if (true) throw e;}
2808       }
2809       expr = VariableDeclaratorId();
2810      list.add(expr);
2811     }
2812     try {
2813       jj_consume_token(RPAREN);
2814     } catch (ParseException e) {
2815     errorMessage = "unexpected token : '"+ e.currentToken.next.image +"', ')' expected";
2816     errorLevel   = ERROR;
2817     errorStart = SimpleCharStream.getPosition() - e.currentToken.next.image.length() + 1;
2818     errorEnd   = SimpleCharStream.getPosition() + 1;
2819     {if (true) throw e;}
2820     }
2821     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2822     case ASSIGN:
2823       jj_consume_token(ASSIGN);
2824       expression = Expression();
2825     String[] strings = new String[list.size()];
2826     list.toArray(strings);
2827     {if (true) return new ListExpression(strings,
2828                               expression,
2829                               pos,
2830                               SimpleCharStream.getPosition());}
2831       break;
2832     default:
2833       jj_la1[79] = jj_gen;
2834       ;
2835     }
2836     String[] strings = new String[list.size()];
2837     list.toArray(strings);
2838     {if (true) return new ListExpression(strings,pos,SimpleCharStream.getPosition());}
2839     throw new Error("Missing return statement in function");
2840   }
2841
2842 /**
2843  * An echo statement.
2844  * echo anyexpression (, otherexpression)*
2845  */
2846   static final public EchoStatement EchoStatement() throws ParseException {
2847   final ArrayList expressions = new ArrayList();
2848   Expression expr;
2849   final int pos = SimpleCharStream.getPosition();
2850     jj_consume_token(ECHO);
2851     expr = Expression();
2852    expressions.add(expr);
2853     label_24:
2854     while (true) {
2855       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2856       case COMMA:
2857         ;
2858         break;
2859       default:
2860         jj_la1[80] = jj_gen;
2861         break label_24;
2862       }
2863       jj_consume_token(COMMA);
2864       expr = Expression();
2865      expressions.add(expr);
2866     }
2867     try {
2868       jj_consume_token(SEMICOLON);
2869     Expression[] exprs = new Expression[expressions.size()];
2870     expressions.toArray(exprs);
2871     {if (true) return new EchoStatement(exprs,pos);}
2872     } catch (ParseException e) {
2873     if (e.currentToken.next.kind != 4) {
2874       errorMessage = "';' expected after 'echo' statement";
2875       errorLevel   = ERROR;
2876       errorStart   = SimpleCharStream.getPosition() - e.currentToken.next.image.length() + 1;
2877       errorEnd     = SimpleCharStream.getPosition() + 1;
2878       {if (true) throw e;}
2879     }
2880     }
2881     throw new Error("Missing return statement in function");
2882   }
2883
2884   static final public GlobalStatement GlobalStatement() throws ParseException {
2885    final int pos = SimpleCharStream.getPosition();
2886    String expr;
2887    ArrayList vars = new ArrayList();
2888    GlobalStatement global;
2889     jj_consume_token(GLOBAL);
2890     expr = VariableDeclaratorId();
2891      vars.add(expr);
2892     label_25:
2893     while (true) {
2894       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2895       case COMMA:
2896         ;
2897         break;
2898       default:
2899         jj_la1[81] = jj_gen;
2900         break label_25;
2901       }
2902       jj_consume_token(COMMA);
2903       expr = VariableDeclaratorId();
2904      vars.add(expr);
2905     }
2906     try {
2907       jj_consume_token(SEMICOLON);
2908     String[] strings = new String[vars.size()];
2909     vars.toArray(strings);
2910     global = new GlobalStatement(currentSegment,
2911                                  strings,
2912                                  pos,
2913                                  SimpleCharStream.getPosition());
2914     currentSegment.add(global);
2915     {if (true) return global;}
2916     } catch (ParseException e) {
2917     errorMessage = "unexpected token : '"+ e.currentToken.next.image +"'. a ';' was expected";
2918     errorLevel   = ERROR;
2919     errorStart = SimpleCharStream.getPosition() - e.currentToken.next.image.length() + 1;
2920     errorEnd   = SimpleCharStream.getPosition() + 1;
2921     {if (true) throw e;}
2922     }
2923     throw new Error("Missing return statement in function");
2924   }
2925
2926   static final public StaticStatement StaticStatement() throws ParseException {
2927   final int pos = SimpleCharStream.getPosition();
2928   final ArrayList vars = new ArrayList();
2929   VariableDeclaration expr;
2930     jj_consume_token(STATIC);
2931     expr = VariableDeclarator();
2932                                         vars.add(new String(expr.name));
2933     label_26:
2934     while (true) {
2935       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2936       case COMMA:
2937         ;
2938         break;
2939       default:
2940         jj_la1[82] = jj_gen;
2941         break label_26;
2942       }
2943       jj_consume_token(COMMA);
2944       expr = VariableDeclarator();
2945                                         vars.add(new String(expr.name));
2946     }
2947     try {
2948       jj_consume_token(SEMICOLON);
2949     String[] strings = new String[vars.size()];
2950     vars.toArray(strings);
2951     {if (true) return new StaticStatement(strings,
2952                                 pos,
2953                                 SimpleCharStream.getPosition());}
2954     } catch (ParseException e) {
2955     errorMessage = "unexpected token : '"+ e.currentToken.next.image +"'. a ';' was expected";
2956     errorLevel   = ERROR;
2957     errorStart = SimpleCharStream.getPosition() - e.currentToken.next.image.length() + 1;
2958     errorEnd   = SimpleCharStream.getPosition() + 1;
2959     {if (true) throw e;}
2960     }
2961     throw new Error("Missing return statement in function");
2962   }
2963
2964   static final public LabeledStatement LabeledStatement() throws ParseException {
2965   final int pos = SimpleCharStream.getPosition();
2966   final Token label;
2967   final Statement statement;
2968     label = jj_consume_token(IDENTIFIER);
2969     jj_consume_token(COLON);
2970     statement = Statement();
2971    {if (true) return new LabeledStatement(label.image.toCharArray(),statement,pos,SimpleCharStream.getPosition());}
2972     throw new Error("Missing return statement in function");
2973   }
2974
2975 /**
2976  * A Block is
2977  * {
2978  * statements
2979  * }.
2980  * @return a block
2981  */
2982   static final public Block Block() throws ParseException {
2983   final int pos = SimpleCharStream.getPosition();
2984   final ArrayList list = new ArrayList();
2985   Statement statement;
2986     try {
2987       jj_consume_token(LBRACE);
2988     } catch (ParseException e) {
2989     errorMessage = "'{' expected";
2990     errorLevel   = ERROR;
2991     errorStart = SimpleCharStream.getPosition() - e.currentToken.next.image.length() + 1;
2992     errorEnd   = SimpleCharStream.getPosition() + 1;
2993     {if (true) throw e;}
2994     }
2995     label_27:
2996     while (true) {
2997       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2998       case PHPEND:
2999       case CLASS:
3000       case FUNCTION:
3001       case IF:
3002       case ARRAY:
3003       case BREAK:
3004       case LIST:
3005       case PRINT:
3006       case ECHO:
3007       case INCLUDE:
3008       case REQUIRE:
3009       case INCLUDE_ONCE:
3010       case REQUIRE_ONCE:
3011       case GLOBAL:
3012       case STATIC:
3013       case CONTINUE:
3014       case DO:
3015       case FOR:
3016       case NEW:
3017       case NULL:
3018       case RETURN:
3019       case SWITCH:
3020       case TRUE:
3021       case FALSE:
3022       case WHILE:
3023       case FOREACH:
3024       case AT:
3025       case DOLLAR:
3026       case BANG:
3027       case INCR:
3028       case DECR:
3029       case PLUS:
3030       case MINUS:
3031       case BIT_AND:
3032       case INTEGER_LITERAL:
3033       case FLOATING_POINT_LITERAL:
3034       case STRING_LITERAL:
3035       case IDENTIFIER:
3036       case LPAREN:
3037       case LBRACE:
3038       case SEMICOLON:
3039       case DOLLAR_ID:
3040         ;
3041         break;
3042       default:
3043         jj_la1[83] = jj_gen;
3044         break label_27;
3045       }
3046       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3047       case CLASS:
3048       case FUNCTION:
3049       case IF:
3050       case ARRAY:
3051       case BREAK:
3052       case LIST:
3053       case PRINT:
3054       case ECHO:
3055       case INCLUDE:
3056       case REQUIRE:
3057       case INCLUDE_ONCE:
3058       case REQUIRE_ONCE:
3059       case GLOBAL:
3060       case STATIC:
3061       case CONTINUE:
3062       case DO:
3063       case FOR:
3064       case NEW:
3065       case NULL:
3066       case RETURN:
3067       case SWITCH:
3068       case TRUE:
3069       case FALSE:
3070       case WHILE:
3071       case FOREACH:
3072       case AT:
3073       case DOLLAR:
3074       case BANG:
3075       case INCR:
3076       case DECR:
3077       case PLUS:
3078       case MINUS:
3079       case BIT_AND:
3080       case INTEGER_LITERAL:
3081       case FLOATING_POINT_LITERAL:
3082       case STRING_LITERAL:
3083       case IDENTIFIER:
3084       case LPAREN:
3085       case LBRACE:
3086       case SEMICOLON:
3087       case DOLLAR_ID:
3088         statement = BlockStatement();
3089                                   list.add(statement);
3090         break;
3091       case PHPEND:
3092         statement = htmlBlock();
3093                                   list.add(statement);
3094         break;
3095       default:
3096         jj_la1[84] = jj_gen;
3097         jj_consume_token(-1);
3098         throw new ParseException();
3099       }
3100     }
3101     try {
3102       jj_consume_token(RBRACE);
3103     } catch (ParseException e) {
3104     errorMessage = "unexpected token : '"+ e.currentToken.image +"', '}' expected";
3105     errorLevel   = ERROR;
3106     errorStart = SimpleCharStream.getPosition() - e.currentToken.next.image.length() + 1;
3107     errorEnd   = SimpleCharStream.getPosition() + 1;
3108     {if (true) throw e;}
3109     }
3110   Statement[] statements = new Statement[list.size()];
3111   list.toArray(statements);
3112   {if (true) return new Block(statements,pos,SimpleCharStream.getPosition());}
3113     throw new Error("Missing return statement in function");
3114   }
3115
3116   static final public Statement BlockStatement() throws ParseException {
3117   final Statement statement;
3118     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3119     case IF:
3120     case ARRAY:
3121     case BREAK:
3122     case LIST:
3123     case PRINT:
3124     case ECHO:
3125     case INCLUDE:
3126     case REQUIRE:
3127     case INCLUDE_ONCE:
3128     case REQUIRE_ONCE:
3129     case GLOBAL:
3130     case STATIC:
3131     case CONTINUE:
3132     case DO:
3133     case FOR:
3134     case NEW:
3135     case NULL:
3136     case RETURN:
3137     case SWITCH:
3138     case TRUE:
3139     case FALSE:
3140     case WHILE:
3141     case FOREACH:
3142     case AT:
3143     case DOLLAR:
3144     case BANG:
3145     case INCR:
3146     case DECR:
3147     case PLUS:
3148     case MINUS:
3149     case BIT_AND:
3150     case INTEGER_LITERAL:
3151     case FLOATING_POINT_LITERAL:
3152     case STRING_LITERAL:
3153     case IDENTIFIER:
3154     case LPAREN:
3155     case LBRACE:
3156     case SEMICOLON:
3157     case DOLLAR_ID:
3158       statement = Statement();
3159                                    {if (true) return statement;}
3160       break;
3161     case CLASS:
3162       statement = ClassDeclaration();
3163                                    {if (true) return statement;}
3164       break;
3165     case FUNCTION:
3166       statement = MethodDeclaration();
3167                                    {if (true) return statement;}
3168       break;
3169     default:
3170       jj_la1[85] = jj_gen;
3171       jj_consume_token(-1);
3172       throw new ParseException();
3173     }
3174     throw new Error("Missing return statement in function");
3175   }
3176
3177 /**
3178  * A Block statement that will not contain any 'break'
3179  */
3180   static final public Statement BlockStatementNoBreak() throws ParseException {
3181   final Statement statement;
3182     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3183     case IF:
3184     case ARRAY:
3185     case LIST:
3186     case PRINT:
3187     case ECHO:
3188     case INCLUDE:
3189     case REQUIRE:
3190     case INCLUDE_ONCE:
3191     case REQUIRE_ONCE:
3192     case GLOBAL:
3193     case STATIC:
3194     case CONTINUE:
3195     case DO:
3196     case FOR:
3197     case NEW:
3198     case NULL:
3199     case RETURN:
3200     case SWITCH:
3201     case TRUE:
3202     case FALSE:
3203     case WHILE:
3204     case FOREACH:
3205     case AT:
3206     case DOLLAR:
3207     case BANG:
3208     case INCR:
3209     case DECR:
3210     case PLUS:
3211     case MINUS:
3212     case BIT_AND:
3213     case INTEGER_LITERAL:
3214     case FLOATING_POINT_LITERAL:
3215     case STRING_LITERAL:
3216     case IDENTIFIER:
3217     case LPAREN:
3218     case LBRACE:
3219     case SEMICOLON:
3220     case DOLLAR_ID:
3221       statement = StatementNoBreak();
3222                                    {if (true) return statement;}
3223       break;
3224     case CLASS:
3225       statement = ClassDeclaration();
3226                                    {if (true) return statement;}
3227       break;
3228     case FUNCTION:
3229       statement = MethodDeclaration();
3230                                    {if (true) return statement;}
3231       break;
3232     default:
3233       jj_la1[86] = jj_gen;
3234       jj_consume_token(-1);
3235       throw new ParseException();
3236     }
3237     throw new Error("Missing return statement in function");
3238   }
3239
3240   static final public VariableDeclaration[] LocalVariableDeclaration() throws ParseException {
3241   final ArrayList list = new ArrayList();
3242   VariableDeclaration var;
3243     var = LocalVariableDeclarator();
3244    list.add(var);
3245     label_28:
3246     while (true) {
3247       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3248       case COMMA:
3249         ;
3250         break;
3251       default:
3252         jj_la1[87] = jj_gen;
3253         break label_28;
3254       }
3255       jj_consume_token(COMMA);
3256       var = LocalVariableDeclarator();
3257                                              list.add(var);
3258     }
3259     VariableDeclaration[] vars = new VariableDeclaration[list.size()];
3260     list.toArray(vars);
3261   {if (true) return vars;}
3262     throw new Error("Missing return statement in function");
3263   }
3264
3265   static final public VariableDeclaration LocalVariableDeclarator() throws ParseException {
3266   final String varName;
3267   Expression initializer = null;
3268   final int pos = SimpleCharStream.getPosition();
3269     varName = VariableDeclaratorId();
3270     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3271     case ASSIGN:
3272       jj_consume_token(ASSIGN);
3273       initializer = Expression();
3274       break;
3275     default:
3276       jj_la1[88] = jj_gen;
3277       ;
3278     }
3279    if (initializer == null) {
3280     {if (true) return new VariableDeclaration(currentSegment,
3281                                   varName.toCharArray(),
3282                                   pos,
3283                                   SimpleCharStream.getPosition());}
3284    }
3285     {if (true) return new VariableDeclaration(currentSegment,
3286                                     varName.toCharArray(),
3287                                     initializer,
3288                                     pos);}
3289     throw new Error("Missing return statement in function");
3290   }
3291
3292   static final public EmptyStatement EmptyStatement() throws ParseException {
3293   final int pos;
3294     jj_consume_token(SEMICOLON);
3295    pos = SimpleCharStream.getPosition();
3296    {if (true) return new EmptyStatement(pos-1,pos);}
3297     throw new Error("Missing return statement in function");
3298   }
3299
3300   static final public Statement StatementExpression() throws ParseException {
3301   Expression expr,expr2;
3302   int operator;
3303     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3304     case INCR:
3305     case DECR:
3306       expr = PreIncDecExpression();
3307                                 {if (true) return expr;}
3308       break;
3309     case ARRAY:
3310     case NEW:
3311     case DOLLAR:
3312     case IDENTIFIER:
3313     case DOLLAR_ID:
3314       expr = PrimaryExpression();
3315       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3316       case INCR:
3317       case DECR:
3318       case ASSIGN:
3319       case PLUSASSIGN:
3320       case MINUSASSIGN:
3321       case STARASSIGN:
3322       case SLASHASSIGN:
3323       case ANDASSIGN:
3324       case ORASSIGN:
3325       case XORASSIGN:
3326       case DOTASSIGN:
3327       case REMASSIGN:
3328       case TILDEEQUAL:
3329       case LSHIFTASSIGN:
3330       case RSIGNEDSHIFTASSIGN:
3331         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3332         case INCR:
3333           jj_consume_token(INCR);
3334             {if (true) return new PostfixedUnaryExpression(expr,
3335                                                 OperatorIds.PLUS_PLUS,
3336                                                 SimpleCharStream.getPosition());}
3337           break;
3338         case DECR:
3339           jj_consume_token(DECR);
3340             {if (true) return new PostfixedUnaryExpression(expr,
3341                                                 OperatorIds.MINUS_MINUS,
3342                                                 SimpleCharStream.getPosition());}
3343           break;
3344         case ASSIGN:
3345         case PLUSASSIGN:
3346         case MINUSASSIGN:
3347         case STARASSIGN:
3348         case SLASHASSIGN:
3349         case ANDASSIGN:
3350         case ORASSIGN:
3351         case XORASSIGN:
3352         case DOTASSIGN:
3353         case REMASSIGN:
3354         case TILDEEQUAL:
3355         case LSHIFTASSIGN:
3356         case RSIGNEDSHIFTASSIGN:
3357           operator = AssignmentOperator();
3358           expr2 = Expression();
3359      {if (true) return new BinaryExpression(expr,expr2,operator);}
3360           break;
3361         default:
3362           jj_la1[89] = jj_gen;
3363           jj_consume_token(-1);
3364           throw new ParseException();
3365         }
3366         break;
3367       default:
3368         jj_la1[90] = jj_gen;
3369         ;
3370       }
3371    {if (true) return expr;}
3372       break;
3373     default:
3374       jj_la1[91] = jj_gen;
3375       jj_consume_token(-1);
3376       throw new ParseException();
3377     }
3378     throw new Error("Missing return statement in function");
3379   }
3380
3381   static final public SwitchStatement SwitchStatement() throws ParseException {
3382   final Expression variable;
3383   final AbstractCase[] cases;
3384   final int pos = SimpleCharStream.getPosition();
3385     jj_consume_token(SWITCH);
3386     try {
3387       jj_consume_token(LPAREN);
3388     } catch (ParseException e) {
3389     errorMessage = "'(' expected after 'switch'";
3390     errorLevel   = ERROR;
3391     errorStart = SimpleCharStream.getPosition() - e.currentToken.next.image.length() + 1;
3392     errorEnd   = SimpleCharStream.getPosition() + 1;
3393     {if (true) throw e;}
3394     }
3395     try {
3396       variable = Expression();
3397     } catch (ParseException e) {
3398     if (errorMessage != null) {
3399       {if (true) throw e;}
3400     }
3401     errorMessage = "expression expected";
3402     errorLevel   = ERROR;
3403     errorStart = SimpleCharStream.getPosition() - e.currentToken.next.image.length() + 1;
3404     errorEnd   = SimpleCharStream.getPosition() + 1;
3405     {if (true) throw e;}
3406     }
3407     try {
3408       jj_consume_token(RPAREN);
3409     } catch (ParseException e) {
3410     errorMessage = "')' expected";
3411     errorLevel   = ERROR;
3412     errorStart = SimpleCharStream.getPosition() - e.currentToken.next.image.length() + 1;
3413     errorEnd   = SimpleCharStream.getPosition() + 1;
3414     {if (true) throw e;}
3415     }
3416     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3417     case LBRACE:
3418       cases = switchStatementBrace();
3419       break;
3420     case COLON:
3421       cases = switchStatementColon(pos, pos + 6);
3422       break;
3423     default:
3424       jj_la1[92] = jj_gen;
3425       jj_consume_token(-1);
3426       throw new ParseException();
3427     }
3428    {if (true) return new SwitchStatement(variable,cases,pos,SimpleCharStream.getPosition());}
3429     throw new Error("Missing return statement in function");
3430   }
3431
3432   static final public AbstractCase[] switchStatementBrace() throws ParseException {
3433   AbstractCase cas;
3434   final ArrayList cases = new ArrayList();
3435     jj_consume_token(LBRACE);
3436     label_29:
3437     while (true) {
3438       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3439       case CASE:
3440       case _DEFAULT:
3441         ;
3442         break;
3443       default:
3444         jj_la1[93] = jj_gen;
3445         break label_29;
3446       }
3447       cas = switchLabel0();
3448                          cases.add(cas);
3449     }
3450     try {
3451       jj_consume_token(RBRACE);
3452     AbstractCase[] abcase = new AbstractCase[cases.size()];
3453     cases.toArray(abcase);
3454     {if (true) return abcase;}
3455     } catch (ParseException e) {
3456     errorMessage = "'}' expected";
3457     errorLevel   = ERROR;
3458     errorStart = SimpleCharStream.getPosition() - e.currentToken.next.image.length() + 1;
3459     errorEnd   = SimpleCharStream.getPosition() + 1;
3460     {if (true) throw e;}
3461     }
3462     throw new Error("Missing return statement in function");
3463   }
3464
3465 /**
3466  * A Switch statement with : ... endswitch;
3467  * @param start the begin offset of the switch
3468  * @param end the end offset of the switch
3469  */
3470   static final public AbstractCase[] switchStatementColon(final int start, final int end) throws ParseException {
3471   AbstractCase cas;
3472   final ArrayList cases = new ArrayList();
3473     jj_consume_token(COLON);
3474    try {
3475   setMarker(fileToParse,
3476             "Ugly syntax detected, you should switch () {...} instead of switch (): ... enswitch;",
3477             start,
3478             end,
3479             INFO,
3480             "Line " + token.beginLine);
3481   } catch (CoreException e) {
3482     PHPeclipsePlugin.log(e);
3483   }
3484     label_30:
3485     while (true) {
3486       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3487       case CASE:
3488       case _DEFAULT:
3489         ;
3490         break;
3491       default:
3492         jj_la1[94] = jj_gen;
3493         break label_30;
3494       }
3495       cas = switchLabel0();
3496                           cases.add(cas);
3497     }
3498     try {
3499       jj_consume_token(ENDSWITCH);
3500     } catch (ParseException e) {
3501     errorMessage = "'endswitch' expected";
3502     errorLevel   = ERROR;
3503     errorStart = SimpleCharStream.getPosition() - e.currentToken.next.image.length() + 1;
3504     errorEnd   = SimpleCharStream.getPosition() + 1;
3505     {if (true) throw e;}
3506     }
3507     try {
3508       jj_consume_token(SEMICOLON);
3509     AbstractCase[] abcase = new AbstractCase[cases.size()];
3510     cases.toArray(abcase);
3511     {if (true) return abcase;}
3512     } catch (ParseException e) {
3513     errorMessage = "';' expected after 'endswitch' keyword";
3514     errorLevel   = ERROR;
3515     errorStart = SimpleCharStream.getPosition() - e.currentToken.next.image.length() + 1;
3516     errorEnd   = SimpleCharStream.getPosition() + 1;
3517     {if (true) throw e;}
3518     }
3519     throw new Error("Missing return statement in function");
3520   }
3521
3522   static final public AbstractCase switchLabel0() throws ParseException {
3523   final Expression expr;
3524   Statement statement;
3525   final ArrayList stmts = new ArrayList();
3526   final int pos = SimpleCharStream.getPosition();
3527     expr = SwitchLabel();
3528     label_31:
3529     while (true) {
3530       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3531       case PHPEND:
3532       case CLASS:
3533       case FUNCTION:
3534       case IF:
3535       case ARRAY:
3536       case LIST:
3537       case PRINT:
3538       case ECHO:
3539       case INCLUDE:
3540       case REQUIRE:
3541       case INCLUDE_ONCE:
3542       case REQUIRE_ONCE:
3543       case GLOBAL:
3544       case STATIC:
3545       case CONTINUE:
3546       case DO:
3547       case FOR:
3548       case NEW:
3549       case NULL:
3550       case RETURN:
3551       case SWITCH:
3552       case TRUE:
3553       case FALSE:
3554       case WHILE:
3555       case FOREACH:
3556       case AT:
3557       case DOLLAR:
3558       case BANG:
3559       case INCR:
3560       case DECR:
3561       case PLUS:
3562       case MINUS:
3563       case BIT_AND:
3564       case INTEGER_LITERAL:
3565       case FLOATING_POINT_LITERAL:
3566       case STRING_LITERAL:
3567       case IDENTIFIER:
3568       case LPAREN:
3569       case LBRACE:
3570       case SEMICOLON:
3571       case DOLLAR_ID:
3572         ;
3573         break;
3574       default:
3575         jj_la1[95] = jj_gen;
3576         break label_31;
3577       }
3578       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3579       case CLASS:
3580       case FUNCTION:
3581       case IF:
3582       case ARRAY:
3583       case LIST:
3584       case PRINT:
3585       case ECHO:
3586       case INCLUDE:
3587       case REQUIRE:
3588       case INCLUDE_ONCE:
3589       case REQUIRE_ONCE:
3590       case GLOBAL:
3591       case STATIC:
3592       case CONTINUE:
3593       case DO:
3594       case FOR:
3595       case NEW:
3596       case NULL:
3597       case RETURN:
3598       case SWITCH:
3599       case TRUE:
3600       case FALSE:
3601       case WHILE:
3602       case FOREACH:
3603       case AT:
3604       case DOLLAR:
3605       case BANG:
3606       case INCR:
3607       case DECR:
3608       case PLUS:
3609       case MINUS:
3610       case BIT_AND:
3611       case INTEGER_LITERAL:
3612       case FLOATING_POINT_LITERAL:
3613       case STRING_LITERAL:
3614       case IDENTIFIER:
3615       case LPAREN:
3616       case LBRACE:
3617       case SEMICOLON:
3618       case DOLLAR_ID:
3619         statement = BlockStatementNoBreak();
3620                                          stmts.add(statement);
3621         break;
3622       case PHPEND:
3623         statement = htmlBlock();
3624                                          stmts.add(statement);
3625         break;
3626       default:
3627         jj_la1[96] = jj_gen;
3628         jj_consume_token(-1);
3629         throw new ParseException();
3630       }
3631     }
3632     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3633     case BREAK:
3634       statement = BreakStatement();
3635                                          stmts.add(statement);
3636       break;
3637     default:
3638       jj_la1[97] = jj_gen;
3639       ;
3640     }
3641   Statement[] stmtsArray = new Statement[stmts.size()];
3642   stmts.toArray(stmtsArray);
3643   if (expr == null) {//it's a default
3644     {if (true) return new DefaultCase(stmtsArray,pos,SimpleCharStream.getPosition());}
3645   }
3646   {if (true) return new Case(expr,stmtsArray,pos,SimpleCharStream.getPosition());}
3647     throw new Error("Missing return statement in function");
3648   }
3649
3650 /**
3651  * A SwitchLabel.
3652  * case Expression() :
3653  * default :
3654  * @return the if it was a case and null if not
3655  */
3656   static final public Expression SwitchLabel() throws ParseException {
3657   final Expression expr;
3658     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3659     case CASE:
3660       token = jj_consume_token(CASE);
3661       try {
3662         expr = Expression();
3663       } catch (ParseException e) {
3664     if (errorMessage != null) {if (true) throw e;}
3665     errorMessage = "expression expected after 'case' keyword";
3666     errorLevel   = ERROR;
3667     errorStart = SimpleCharStream.getPosition() - e.currentToken.next.image.length() + 1;
3668     errorEnd   = SimpleCharStream.getPosition() + 1;
3669     {if (true) throw e;}
3670       }
3671       try {
3672         jj_consume_token(COLON);
3673      {if (true) return expr;}
3674       } catch (ParseException e) {
3675     errorMessage = "':' expected after case expression";
3676     errorLevel   = ERROR;
3677     errorStart = SimpleCharStream.getPosition() - e.currentToken.next.image.length() + 1;
3678     errorEnd   = SimpleCharStream.getPosition() + 1;
3679     {if (true) throw e;}
3680       }
3681       break;
3682     case _DEFAULT:
3683       token = jj_consume_token(_DEFAULT);
3684       try {
3685         jj_consume_token(COLON);
3686      {if (true) return null;}
3687       } catch (ParseException e) {
3688     errorMessage = "':' expected after 'default' keyword";
3689     errorLevel   = ERROR;
3690     errorStart = SimpleCharStream.getPosition() - e.currentToken.next.image.length() + 1;
3691     errorEnd   = SimpleCharStream.getPosition() + 1;
3692     {if (true) throw e;}
3693       }
3694       break;
3695     default:
3696       jj_la1[98] = jj_gen;
3697       jj_consume_token(-1);
3698       throw new ParseException();
3699     }
3700     throw new Error("Missing return statement in function");
3701   }
3702
3703   static final public Break BreakStatement() throws ParseException {
3704   Expression expression = null;
3705   final int start = SimpleCharStream.getPosition();
3706     jj_consume_token(BREAK);
3707     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3708     case ARRAY:
3709     case LIST:
3710     case PRINT:
3711     case NEW:
3712     case NULL:
3713     case TRUE:
3714     case FALSE:
3715     case AT:
3716     case DOLLAR:
3717     case BANG:
3718     case INCR:
3719     case DECR:
3720     case PLUS:
3721     case MINUS:
3722     case BIT_AND:
3723     case INTEGER_LITERAL:
3724     case FLOATING_POINT_LITERAL:
3725     case STRING_LITERAL:
3726     case IDENTIFIER:
3727     case LPAREN:
3728     case DOLLAR_ID:
3729       expression = Expression();
3730       break;
3731     default:
3732       jj_la1[99] = jj_gen;
3733       ;
3734     }
3735     try {
3736       jj_consume_token(SEMICOLON);
3737     } catch (ParseException e) {
3738     errorMessage = "';' expected after 'break' keyword";
3739     errorLevel   = ERROR;
3740     errorStart = SimpleCharStream.getPosition() - e.currentToken.next.image.length() + 1;
3741     errorEnd   = SimpleCharStream.getPosition() + 1;
3742     {if (true) throw e;}
3743     }
3744    {if (true) return new Break(expression, start, SimpleCharStream.getPosition());}
3745     throw new Error("Missing return statement in function");
3746   }
3747
3748   static final public IfStatement IfStatement() throws ParseException {
3749   final int pos = SimpleCharStream.getPosition();
3750   Expression condition;
3751   IfStatement ifStatement;
3752     jj_consume_token(IF);
3753     condition = Condition("if");
3754     ifStatement = IfStatement0(condition, pos,pos+2);
3755    {if (true) return ifStatement;}
3756     throw new Error("Missing return statement in function");
3757   }
3758
3759   static final public Expression Condition(final String keyword) throws ParseException {
3760   final Expression condition;
3761     try {
3762       jj_consume_token(LPAREN);
3763     } catch (ParseException e) {
3764     errorMessage = "'(' expected after " + keyword + " keyword";
3765     errorLevel   = ERROR;
3766     errorStart = SimpleCharStream.getPosition() - e.currentToken.next.image.length();
3767     errorEnd   = errorStart +1;
3768     processParseException(e);
3769     }
3770     condition = Expression();
3771     try {
3772       jj_consume_token(RPAREN);
3773       {if (true) return condition;}
3774     } catch (ParseException e) {
3775     errorMessage = "')' expected after " + keyword + " keyword";
3776     errorLevel   = ERROR;
3777     errorStart = SimpleCharStream.getPosition() - e.currentToken.next.image.length() + 1;
3778     errorEnd   = SimpleCharStream.getPosition() + 1;
3779     {if (true) throw e;}
3780     }
3781     throw new Error("Missing return statement in function");
3782   }
3783
3784   static final public IfStatement IfStatement0(Expression condition, final int start,final int end) throws ParseException {
3785   Statement statement;
3786   Statement stmt;
3787   final Statement[] statementsArray;
3788   ElseIf elseifStatement;
3789   Else elseStatement = null;
3790   ArrayList stmts;
3791   final ArrayList elseIfList = new ArrayList();
3792   ElseIf[] elseIfs;
3793   int pos = SimpleCharStream.getPosition();
3794   int endStatements;
3795     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3796     case COLON:
3797       jj_consume_token(COLON);
3798    stmts = new ArrayList();
3799       label_32:
3800       while (true) {
3801         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3802         case PHPEND:
3803         case IF:
3804         case ARRAY:
3805         case BREAK:
3806         case LIST:
3807         case PRINT:
3808         case ECHO:
3809         case INCLUDE:
3810         case REQUIRE:
3811         case INCLUDE_ONCE:
3812         case REQUIRE_ONCE:
3813         case GLOBAL:
3814         case STATIC:
3815         case CONTINUE:
3816         case DO:
3817         case FOR:
3818         case NEW:
3819         case NULL:
3820         case RETURN:
3821         case SWITCH:
3822         case TRUE:
3823         case FALSE:
3824         case WHILE:
3825         case FOREACH:
3826         case AT:
3827         case DOLLAR:
3828         case BANG:
3829         case INCR:
3830         case DECR:
3831         case PLUS:
3832         case MINUS:
3833         case BIT_AND:
3834         case INTEGER_LITERAL:
3835         case FLOATING_POINT_LITERAL:
3836         case STRING_LITERAL:
3837         case IDENTIFIER:
3838         case LPAREN:
3839         case LBRACE:
3840         case SEMICOLON:
3841         case DOLLAR_ID:
3842           ;
3843           break;
3844         default:
3845           jj_la1[100] = jj_gen;
3846           break label_32;
3847         }
3848         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3849         case IF:
3850         case ARRAY:
3851         case BREAK:
3852         case LIST:
3853         case PRINT:
3854         case ECHO:
3855         case INCLUDE:
3856         case REQUIRE:
3857         case INCLUDE_ONCE:
3858         case REQUIRE_ONCE:
3859         case GLOBAL:
3860         case STATIC:
3861         case CONTINUE:
3862         case DO:
3863         case FOR:
3864         case NEW:
3865         case NULL:
3866         case RETURN:
3867         case SWITCH:
3868         case TRUE:
3869         case FALSE:
3870         case WHILE:
3871         case FOREACH:
3872         case AT:
3873         case DOLLAR:
3874         case BANG:
3875         case INCR:
3876         case DECR:
3877         case PLUS:
3878         case MINUS:
3879         case BIT_AND:
3880         case INTEGER_LITERAL:
3881         case FLOATING_POINT_LITERAL:
3882         case STRING_LITERAL:
3883         case IDENTIFIER:
3884         case LPAREN:
3885         case LBRACE:
3886         case SEMICOLON:
3887         case DOLLAR_ID:
3888           statement = Statement();
3889                               stmts.add(statement);
3890           break;
3891         case PHPEND:
3892           statement = htmlBlock();
3893                               stmts.add(statement);
3894           break;
3895         default:
3896           jj_la1[101] = jj_gen;
3897           jj_consume_token(-1);
3898           throw new ParseException();
3899         }
3900       }
3901     endStatements = SimpleCharStream.getPosition();
3902       label_33:
3903       while (true) {
3904         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3905         case ELSEIF:
3906           ;
3907           break;
3908         default:
3909           jj_la1[102] = jj_gen;
3910           break label_33;
3911         }
3912         elseifStatement = ElseIfStatementColon();
3913                                               elseIfList.add(elseifStatement);
3914       }
3915       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3916       case ELSE:
3917         elseStatement = ElseStatementColon();
3918         break;
3919       default:
3920         jj_la1[103] = jj_gen;
3921         ;
3922       }
3923    try {
3924   setMarker(fileToParse,
3925             "Ugly syntax detected, you should if () {...} instead of if (): ... endif;",
3926             start,
3927             end,
3928             INFO,
3929             "Line " + token.beginLine);
3930   } catch (CoreException e) {
3931     PHPeclipsePlugin.log(e);
3932   }
3933       try {
3934         jj_consume_token(ENDIF);
3935       } catch (ParseException e) {
3936     errorMessage = "'endif' expected";
3937     errorLevel   = ERROR;
3938     errorStart = SimpleCharStream.getPosition() - e.currentToken.next.image.length() + 1;
3939     errorEnd   = SimpleCharStream.getPosition() + 1;
3940     {if (true) throw e;}
3941       }
3942       try {
3943         jj_consume_token(SEMICOLON);
3944       } catch (ParseException e) {
3945     errorMessage = "';' expected after 'endif' keyword";
3946     errorLevel   = ERROR;
3947     errorStart = SimpleCharStream.getPosition() - e.currentToken.next.image.length() + 1;
3948     errorEnd   = SimpleCharStream.getPosition() + 1;
3949     {if (true) throw e;}
3950       }
3951     elseIfs = new ElseIf[elseIfList.size()];
3952     elseIfList.toArray(elseIfs);
3953     if (stmts.size() == 1) {
3954       {if (true) return new IfStatement(condition,
3955                              (Statement) stmts.get(0),
3956                               elseIfs,
3957                               elseStatement,
3958                               pos,
3959                               SimpleCharStream.getPosition());}
3960     } else {
3961       statementsArray = new Statement[stmts.size()];
3962       stmts.toArray(statementsArray);
3963       {if (true) return new IfStatement(condition,
3964                              new Block(statementsArray,pos,endStatements),
3965                               elseIfs,
3966                               elseStatement,
3967                               pos,
3968                               SimpleCharStream.getPosition());}
3969     }
3970       break;
3971     case PHPEND:
3972     case IF:
3973     case ARRAY:
3974     case BREAK:
3975     case LIST:
3976     case PRINT:
3977     case ECHO:
3978     case INCLUDE:
3979     case REQUIRE:
3980     case INCLUDE_ONCE:
3981     case REQUIRE_ONCE:
3982     case GLOBAL:
3983     case STATIC:
3984     case CONTINUE:
3985     case DO:
3986     case FOR:
3987     case NEW:
3988     case NULL:
3989     case RETURN:
3990     case SWITCH:
3991     case TRUE:
3992     case FALSE:
3993     case WHILE:
3994     case FOREACH:
3995     case AT:
3996     case DOLLAR:
3997     case BANG:
3998     case INCR:
3999     case DECR:
4000     case PLUS:
4001     case MINUS:
4002     case BIT_AND:
4003     case INTEGER_LITERAL:
4004     case FLOATING_POINT_LITERAL:
4005     case STRING_LITERAL:
4006     case IDENTIFIER:
4007     case LPAREN:
4008     case LBRACE:
4009     case SEMICOLON:
4010     case DOLLAR_ID:
4011       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
4012       case IF:
4013       case ARRAY:
4014       case BREAK:
4015       case LIST:
4016       case PRINT:
4017       case ECHO:
4018       case INCLUDE:
4019       case REQUIRE:
4020       case INCLUDE_ONCE:
4021       case REQUIRE_ONCE:
4022       case GLOBAL:
4023       case STATIC:
4024       case CONTINUE:
4025       case DO:
4026       case FOR:
4027       case NEW:
4028       case NULL:
4029       case RETURN:
4030       case SWITCH:
4031       case TRUE:
4032       case FALSE:
4033       case WHILE:
4034       case FOREACH:
4035       case AT:
4036       case DOLLAR:
4037       case BANG:
4038       case INCR:
4039       case DECR:
4040       case PLUS:
4041       case MINUS:
4042       case BIT_AND:
4043       case INTEGER_LITERAL:
4044       case FLOATING_POINT_LITERAL:
4045       case STRING_LITERAL:
4046       case IDENTIFIER:
4047       case LPAREN:
4048       case LBRACE:
4049       case SEMICOLON:
4050       case DOLLAR_ID:
4051         stmt = Statement();
4052         break;
4053       case PHPEND:
4054         stmt = htmlBlock();
4055         break;
4056       default:
4057         jj_la1[104] = jj_gen;
4058         jj_consume_token(-1);
4059         throw new ParseException();
4060       }
4061       label_34:
4062       while (true) {
4063         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
4064         case ELSEIF:
4065           ;
4066           break;
4067         default:
4068           jj_la1[105] = jj_gen;
4069           break label_34;
4070         }
4071         elseifStatement = ElseIfStatement();
4072                                                       elseIfList.add(elseifStatement);
4073       }
4074       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
4075       case ELSE:
4076         jj_consume_token(ELSE);
4077         try {
4078        pos = SimpleCharStream.getPosition();
4079           statement = Statement();
4080        elseStatement = new Else(statement,pos,SimpleCharStream.getPosition());
4081         } catch (ParseException e) {
4082       if (errorMessage != null) {
4083         {if (true) throw e;}
4084       }
4085       errorMessage = "unexpected token '"+e.currentToken.next.image+"', a statement was expected";
4086       errorLevel   = ERROR;
4087       errorStart = SimpleCharStream.getPosition() - e.currentToken.next.image.length() + 1;
4088       errorEnd   = SimpleCharStream.getPosition() + 1;
4089       {if (true) throw e;}
4090         }
4091         break;
4092       default:
4093         jj_la1[106] = jj_gen;
4094         ;
4095       }
4096     elseIfs = new ElseIf[elseIfList.size()];
4097     elseIfList.toArray(elseIfs);
4098     {if (true) return new IfStatement(condition,
4099                            stmt,
4100                            elseIfs,
4101                            elseStatement,
4102                            pos,
4103                            SimpleCharStream.getPosition());}
4104       break;
4105     default:
4106       jj_la1[107] = jj_gen;
4107       jj_consume_token(-1);
4108       throw new ParseException();
4109     }
4110     throw new Error("Missing return statement in function");
4111   }
4112
4113   static final public ElseIf ElseIfStatementColon() throws ParseException {
4114   Expression condition;
4115   Statement statement;
4116   final ArrayList list = new ArrayList();
4117   final int pos = SimpleCharStream.getPosition();
4118     jj_consume_token(ELSEIF);
4119     condition = Condition("elseif");
4120     jj_consume_token(COLON);
4121     label_35:
4122     while (true) {
4123       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
4124       case PHPEND:
4125       case IF:
4126       case ARRAY:
4127       case BREAK:
4128       case LIST:
4129       case PRINT:
4130       case ECHO:
4131       case INCLUDE:
4132       case REQUIRE:
4133       case INCLUDE_ONCE:
4134       case REQUIRE_ONCE:
4135       case GLOBAL:
4136       case STATIC:
4137       case CONTINUE:
4138       case DO:
4139       case FOR:
4140       case NEW:
4141       case NULL:
4142       case RETURN:
4143       case SWITCH:
4144       case TRUE:
4145       case FALSE:
4146       case WHILE:
4147       case FOREACH:
4148       case AT:
4149       case DOLLAR:
4150       case BANG:
4151       case INCR:
4152       case DECR:
4153       case PLUS:
4154       case MINUS:
4155       case BIT_AND:
4156       case INTEGER_LITERAL:
4157       case FLOATING_POINT_LITERAL:
4158       case STRING_LITERAL:
4159       case IDENTIFIER:
4160       case LPAREN:
4161       case LBRACE:
4162       case SEMICOLON:
4163       case DOLLAR_ID:
4164         ;
4165         break;
4166       default:
4167         jj_la1[108] = jj_gen;
4168         break label_35;
4169       }
4170       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
4171       case IF:
4172       case ARRAY:
4173       case BREAK:
4174       case LIST:
4175       case PRINT:
4176       case ECHO:
4177       case INCLUDE:
4178       case REQUIRE:
4179       case INCLUDE_ONCE:
4180       case REQUIRE_ONCE:
4181       case GLOBAL:
4182       case STATIC:
4183       case CONTINUE:
4184       case DO:
4185       case FOR:
4186       case NEW:
4187       case NULL:
4188       case RETURN:
4189       case SWITCH:
4190       case TRUE:
4191       case FALSE:
4192       case WHILE:
4193       case FOREACH:
4194       case AT:
4195       case DOLLAR:
4196       case BANG:
4197       case INCR:
4198       case DECR:
4199       case PLUS:
4200       case MINUS:
4201       case BIT_AND:
4202       case INTEGER_LITERAL:
4203       case FLOATING_POINT_LITERAL:
4204       case STRING_LITERAL:
4205       case IDENTIFIER:
4206       case LPAREN:
4207       case LBRACE:
4208       case SEMICOLON:
4209       case DOLLAR_ID:
4210         statement = Statement();
4211                                       list.add(statement);
4212         break;
4213       case PHPEND:
4214         statement = htmlBlock();
4215                                       list.add(statement);
4216         break;
4217       default:
4218         jj_la1[109] = jj_gen;
4219         jj_consume_token(-1);
4220         throw new ParseException();
4221       }
4222     }
4223   Statement[] stmtsArray = new Statement[list.size()];
4224   list.toArray(stmtsArray);
4225   {if (true) return new ElseIf(condition,stmtsArray ,pos,SimpleCharStream.getPosition());}
4226     throw new Error("Missing return statement in function");
4227   }
4228
4229   static final public Else ElseStatementColon() throws ParseException {
4230   Statement statement;
4231   final ArrayList list = new ArrayList();
4232   final int pos = SimpleCharStream.getPosition();
4233     jj_consume_token(ELSE);
4234     jj_consume_token(COLON);
4235     label_36:
4236     while (true) {
4237       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
4238       case PHPEND:
4239       case IF:
4240       case ARRAY:
4241       case BREAK:
4242       case LIST:
4243       case PRINT:
4244       case ECHO:
4245       case INCLUDE:
4246       case REQUIRE:
4247       case INCLUDE_ONCE:
4248       case REQUIRE_ONCE:
4249       case GLOBAL:
4250       case STATIC:
4251       case CONTINUE:
4252       case DO:
4253       case FOR:
4254       case NEW:
4255       case NULL:
4256       case RETURN:
4257       case SWITCH:
4258       case TRUE:
4259       case FALSE:
4260       case WHILE:
4261       case FOREACH:
4262       case AT:
4263       case DOLLAR:
4264       case BANG:
4265       case INCR:
4266       case DECR:
4267       case PLUS:
4268       case MINUS:
4269       case BIT_AND:
4270       case INTEGER_LITERAL:
4271       case FLOATING_POINT_LITERAL:
4272       case STRING_LITERAL:
4273       case IDENTIFIER:
4274       case LPAREN:
4275       case LBRACE:
4276       case SEMICOLON:
4277       case DOLLAR_ID:
4278         ;
4279         break;
4280       default:
4281         jj_la1[110] = jj_gen;
4282         break label_36;
4283       }
4284       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
4285       case IF:
4286       case ARRAY:
4287       case BREAK:
4288       case LIST:
4289       case PRINT:
4290       case ECHO:
4291       case INCLUDE:
4292       case REQUIRE:
4293       case INCLUDE_ONCE:
4294       case REQUIRE_ONCE:
4295       case GLOBAL:
4296       case STATIC:
4297       case CONTINUE:
4298       case DO:
4299       case FOR:
4300       case NEW:
4301       case NULL:
4302       case RETURN:
4303       case SWITCH:
4304       case TRUE:
4305       case FALSE:
4306       case WHILE:
4307       case FOREACH:
4308       case AT:
4309       case DOLLAR:
4310       case BANG:
4311       case INCR:
4312       case DECR:
4313       case PLUS:
4314       case MINUS:
4315       case BIT_AND:
4316       case INTEGER_LITERAL:
4317       case FLOATING_POINT_LITERAL:
4318       case STRING_LITERAL:
4319       case IDENTIFIER:
4320       case LPAREN:
4321       case LBRACE:
4322       case SEMICOLON:
4323       case DOLLAR_ID:
4324         statement = Statement();
4325                                              list.add(statement);
4326         break;
4327       case PHPEND:
4328         statement = htmlBlock();
4329                                              list.add(statement);
4330         break;
4331       default:
4332         jj_la1[111] = jj_gen;
4333         jj_consume_token(-1);
4334         throw new ParseException();
4335       }
4336     }
4337   Statement[] stmtsArray = new Statement[list.size()];
4338   list.toArray(stmtsArray);
4339   {if (true) return new Else(stmtsArray,pos,SimpleCharStream.getPosition());}
4340     throw new Error("Missing return statement in function");
4341   }
4342
4343   static final public ElseIf ElseIfStatement() throws ParseException {
4344   Expression condition;
4345   Statement statement;
4346   final ArrayList list = new ArrayList();
4347   final int pos = SimpleCharStream.getPosition();
4348     jj_consume_token(ELSEIF);
4349     condition = Condition("elseif");
4350     statement = Statement();
4351                                                                     list.add(statement);/*todo:do better*/
4352   Statement[] stmtsArray = new Statement[list.size()];
4353   list.toArray(stmtsArray);
4354   {if (true) return new ElseIf(condition,stmtsArray,pos,SimpleCharStream.getPosition());}
4355     throw new Error("Missing return statement in function");
4356   }
4357
4358   static final public WhileStatement WhileStatement() throws ParseException {
4359   final Expression condition;
4360   final Statement action;
4361   final int pos = SimpleCharStream.getPosition();
4362     jj_consume_token(WHILE);
4363     condition = Condition("while");
4364     action = WhileStatement0(pos,pos + 5);
4365      {if (true) return new WhileStatement(condition,action,pos,SimpleCharStream.getPosition());}
4366     throw new Error("Missing return statement in function");
4367   }
4368
4369   static final public Statement WhileStatement0(final int start, final int end) throws ParseException {
4370   Statement statement;
4371   final ArrayList stmts = new ArrayList();
4372   final int pos = SimpleCharStream.getPosition();
4373     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
4374     case COLON:
4375       jj_consume_token(COLON);
4376       label_37:
4377       while (true) {
4378         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
4379         case IF:
4380         case ARRAY:
4381         case BREAK:
4382         case LIST:
4383         case PRINT:
4384         case ECHO:
4385         case INCLUDE:
4386         case REQUIRE:
4387         case INCLUDE_ONCE:
4388         case REQUIRE_ONCE:
4389         case GLOBAL:
4390         case STATIC:
4391         case CONTINUE:
4392         case DO:
4393         case FOR:
4394         case NEW:
4395         case NULL:
4396         case RETURN:
4397         case SWITCH:
4398         case TRUE:
4399         case FALSE:
4400         case WHILE:
4401         case FOREACH:
4402         case AT:
4403         case DOLLAR:
4404         case BANG:
4405         case INCR:
4406         case DECR:
4407         case PLUS:
4408         case MINUS:
4409         case BIT_AND:
4410         case INTEGER_LITERAL:
4411         case FLOATING_POINT_LITERAL:
4412         case STRING_LITERAL:
4413         case IDENTIFIER:
4414         case LPAREN:
4415         case LBRACE:
4416         case SEMICOLON:
4417         case DOLLAR_ID:
4418           ;
4419           break;
4420         default:
4421           jj_la1[112] = jj_gen;
4422           break label_37;
4423         }
4424         statement = Statement();
4425                                     stmts.add(statement);
4426       }
4427    try {
4428   setMarker(fileToParse,
4429             "Ugly syntax detected, you should while () {...} instead of while (): ... endwhile;",
4430             start,
4431             end,
4432             INFO,
4433             "Line " + token.beginLine);
4434   } catch (CoreException e) {
4435     PHPeclipsePlugin.log(e);
4436   }
4437       try {
4438         jj_consume_token(ENDWHILE);
4439       } catch (ParseException e) {
4440     errorMessage = "'endwhile' expected";
4441     errorLevel   = ERROR;
4442     errorStart = SimpleCharStream.getPosition() - e.currentToken.next.image.length() + 1;
4443     errorEnd   = SimpleCharStream.getPosition() + 1;
4444     {if (true) throw e;}
4445       }
4446       try {
4447         jj_consume_token(SEMICOLON);
4448     Statement[] stmtsArray = new Statement[stmts.size()];
4449     stmts.toArray(stmtsArray);
4450     {if (true) return new Block(stmtsArray,pos,SimpleCharStream.getPosition());}
4451       } catch (ParseException e) {
4452     errorMessage = "';' expected after 'endwhile' keyword";
4453     errorLevel   = ERROR;
4454     errorStart = SimpleCharStream.getPosition() - e.currentToken.next.image.length() + 1;
4455     errorEnd   = SimpleCharStream.getPosition() + 1;
4456     {if (true) throw e;}
4457       }
4458       break;
4459     case IF:
4460     case ARRAY:
4461     case BREAK:
4462     case LIST:
4463     case PRINT:
4464     case ECHO:
4465     case INCLUDE:
4466     case REQUIRE:
4467     case INCLUDE_ONCE:
4468     case REQUIRE_ONCE:
4469     case GLOBAL:
4470     case STATIC:
4471     case CONTINUE:
4472     case DO:
4473     case FOR:
4474     case NEW:
4475     case NULL:
4476     case RETURN:
4477     case SWITCH:
4478     case TRUE:
4479     case FALSE:
4480     case WHILE:
4481     case FOREACH:
4482     case AT:
4483     case DOLLAR:
4484     case BANG:
4485     case INCR:
4486     case DECR:
4487     case PLUS:
4488     case MINUS:
4489     case BIT_AND:
4490     case INTEGER_LITERAL:
4491     case FLOATING_POINT_LITERAL:
4492     case STRING_LITERAL:
4493     case IDENTIFIER:
4494     case LPAREN:
4495     case LBRACE:
4496     case SEMICOLON:
4497     case DOLLAR_ID:
4498       statement = Statement();
4499    {if (true) return statement;}
4500       break;
4501     default:
4502       jj_la1[113] = jj_gen;
4503       jj_consume_token(-1);
4504       throw new ParseException();
4505     }
4506     throw new Error("Missing return statement in function");
4507   }
4508
4509   static final public DoStatement DoStatement() throws ParseException {
4510   final Statement action;
4511   final Expression condition;
4512   final int pos = SimpleCharStream.getPosition();
4513     jj_consume_token(DO);
4514     action = Statement();
4515     jj_consume_token(WHILE);
4516     condition = Condition("while");
4517     try {
4518       jj_consume_token(SEMICOLON);
4519      {if (true) return new DoStatement(condition,action,pos,SimpleCharStream.getPosition());}
4520     } catch (ParseException e) {
4521     errorMessage = "unexpected token : '"+ e.currentToken.next.image +"'. A ';' was expected";
4522     errorLevel   = ERROR;
4523     errorStart = SimpleCharStream.getPosition() - e.currentToken.next.image.length() + 1;
4524     errorEnd   = SimpleCharStream.getPosition() + 1;
4525     {if (true) throw e;}
4526     }
4527     throw new Error("Missing return statement in function");
4528   }
4529
4530   static final public ForeachStatement ForeachStatement() throws ParseException {
4531   Statement statement;
4532   Expression expression;
4533   final int pos = SimpleCharStream.getPosition();
4534   ArrayVariableDeclaration variable;
4535     jj_consume_token(FOREACH);
4536     try {
4537       jj_consume_token(LPAREN);
4538     } catch (ParseException e) {
4539     errorMessage = "'(' expected after 'foreach' keyword";
4540     errorLevel   = ERROR;
4541     errorStart = SimpleCharStream.getPosition() - e.currentToken.next.image.length() + 1;
4542     errorEnd   = SimpleCharStream.getPosition() + 1;
4543     {if (true) throw e;}
4544     }
4545     try {
4546       expression = Expression();
4547     } catch (ParseException e) {
4548     errorMessage = "variable expected";
4549     errorLevel   = ERROR;
4550     errorStart = SimpleCharStream.getPosition() - e.currentToken.next.image.length() + 1;
4551     errorEnd   = SimpleCharStream.getPosition() + 1;
4552     {if (true) throw e;}
4553     }
4554     try {
4555       jj_consume_token(AS);
4556     } catch (ParseException e) {
4557     errorMessage = "'as' expected";
4558     errorLevel   = ERROR;
4559     errorStart = SimpleCharStream.getPosition() - e.currentToken.next.image.length() + 1;
4560     errorEnd   = SimpleCharStream.getPosition() + 1;
4561     {if (true) throw e;}
4562     }
4563     try {
4564       variable = ArrayVariable();
4565     } catch (ParseException e) {
4566     errorMessage = "variable expected";
4567     errorLevel   = ERROR;
4568     errorStart = SimpleCharStream.getPosition() - e.currentToken.next.image.length() + 1;
4569     errorEnd   = SimpleCharStream.getPosition() + 1;
4570     {if (true) throw e;}
4571     }
4572     try {
4573       jj_consume_token(RPAREN);
4574     } catch (ParseException e) {
4575     errorMessage = "')' expected after 'foreach' keyword";
4576     errorLevel   = ERROR;
4577     errorStart = SimpleCharStream.getPosition() - e.currentToken.next.image.length() + 1;
4578     errorEnd   = SimpleCharStream.getPosition() + 1;
4579     {if (true) throw e;}
4580     }
4581     try {
4582       statement = Statement();
4583     } catch (ParseException e) {
4584     if (errorMessage != null) {if (true) throw e;}
4585     errorMessage = "statement expected";
4586     errorLevel   = ERROR;
4587     errorStart = SimpleCharStream.getPosition() - e.currentToken.next.image.length() + 1;
4588     errorEnd   = SimpleCharStream.getPosition() + 1;
4589     {if (true) throw e;}
4590     }
4591    {if (true) return new ForeachStatement(expression,
4592                                variable,
4593                                statement,
4594                                pos,
4595                                SimpleCharStream.getPosition());}
4596     throw new Error("Missing return statement in function");
4597   }
4598
4599   static final public ForStatement ForStatement() throws ParseException {
4600 final Token token;
4601 final int pos = SimpleCharStream.getPosition();
4602 Statement[] initializations = null;
4603 Expression condition = null;
4604 Statement[] increments = null;
4605 Statement action;
4606 final ArrayList list = new ArrayList();
4607 final int startBlock, endBlock;
4608     token = jj_consume_token(FOR);
4609     try {
4610       jj_consume_token(LPAREN);
4611     } catch (ParseException e) {
4612     errorMessage = "'(' expected after 'for' keyword";
4613     errorLevel   = ERROR;
4614     errorStart = SimpleCharStream.getPosition() - e.currentToken.next.image.length() + 1;
4615     errorEnd   = SimpleCharStream.getPosition() + 1;
4616     {if (true) throw e;}
4617     }
4618     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
4619     case ARRAY:
4620     case NEW:
4621     case DOLLAR:
4622     case INCR:
4623     case DECR:
4624     case IDENTIFIER:
4625     case DOLLAR_ID:
4626       initializations = ForInit();
4627       break;
4628     default:
4629       jj_la1[114] = jj_gen;
4630       ;
4631     }
4632     jj_consume_token(SEMICOLON);
4633     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
4634     case ARRAY:
4635     case LIST:
4636     case PRINT:
4637     case NEW:
4638     case NULL:
4639     case TRUE:
4640     case FALSE:
4641     case AT:
4642     case DOLLAR:
4643     case BANG:
4644     case INCR:
4645     case DECR:
4646     case PLUS:
4647     case MINUS:
4648     case BIT_AND:
4649     case INTEGER_LITERAL:
4650     case FLOATING_POINT_LITERAL:
4651     case STRING_LITERAL:
4652     case IDENTIFIER:
4653     case LPAREN:
4654     case DOLLAR_ID:
4655       condition = Expression();
4656       break;
4657     default:
4658       jj_la1[115] = jj_gen;
4659       ;
4660     }
4661     jj_consume_token(SEMICOLON);
4662     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
4663     case ARRAY:
4664     case NEW:
4665     case DOLLAR:
4666     case INCR:
4667     case DECR:
4668     case IDENTIFIER:
4669     case DOLLAR_ID:
4670       increments = StatementExpressionList();
4671       break;
4672     default:
4673       jj_la1[116] = jj_gen;
4674       ;
4675     }
4676     jj_consume_token(RPAREN);
4677     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
4678     case IF:
4679     case ARRAY:
4680     case BREAK:
4681     case LIST:
4682     case PRINT:
4683     case ECHO:
4684     case INCLUDE:
4685     case REQUIRE:
4686     case INCLUDE_ONCE:
4687     case REQUIRE_ONCE:
4688     case GLOBAL:
4689     case STATIC:
4690     case CONTINUE:
4691     case DO:
4692     case FOR:
4693     case NEW:
4694     case NULL:
4695     case RETURN:
4696     case SWITCH:
4697     case TRUE:
4698     case FALSE:
4699     case WHILE:
4700     case FOREACH:
4701     case AT:
4702     case DOLLAR:
4703     case BANG:
4704     case INCR:
4705     case DECR:
4706     case PLUS:
4707     case MINUS:
4708     case BIT_AND:
4709     case INTEGER_LITERAL:
4710     case FLOATING_POINT_LITERAL:
4711     case STRING_LITERAL:
4712     case IDENTIFIER:
4713     case LPAREN:
4714     case LBRACE:
4715     case SEMICOLON:
4716     case DOLLAR_ID:
4717       action = Statement();
4718        {if (true) return new ForStatement(initializations,condition,increments,action,pos,SimpleCharStream.getPosition());}
4719       break;
4720     case COLON:
4721       jj_consume_token(COLON);
4722        startBlock = SimpleCharStream.getPosition();
4723       label_38:
4724       while (true) {
4725         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
4726         case IF:
4727         case ARRAY:
4728         case BREAK:
4729         case LIST:
4730         case PRINT:
4731         case ECHO:
4732         case INCLUDE:
4733         case REQUIRE:
4734         case INCLUDE_ONCE:
4735         case REQUIRE_ONCE:
4736         case GLOBAL:
4737         case STATIC:
4738         case CONTINUE:
4739         case DO:
4740         case FOR:
4741         case NEW:
4742         case NULL:
4743         case RETURN:
4744         case SWITCH:
4745         case TRUE:
4746         case FALSE:
4747         case WHILE:
4748         case FOREACH:
4749         case AT:
4750         case DOLLAR:
4751         case BANG:
4752         case INCR:
4753         case DECR:
4754         case PLUS:
4755         case MINUS:
4756         case BIT_AND:
4757         case INTEGER_LITERAL:
4758         case FLOATING_POINT_LITERAL:
4759         case STRING_LITERAL:
4760         case IDENTIFIER:
4761         case LPAREN:
4762         case LBRACE:
4763         case SEMICOLON:
4764         case DOLLAR_ID:
4765           ;
4766           break;
4767         default:
4768           jj_la1[117] = jj_gen;
4769           break label_38;
4770         }
4771         action = Statement();
4772                              list.add(action);
4773       }
4774         try {
4775         setMarker(fileToParse,
4776                   "Ugly syntax detected, you should for () {...} instead of for (): ... endfor;",
4777                   pos,
4778                   pos+token.image.length(),
4779                   INFO,
4780                   "Line " + token.beginLine);
4781         } catch (CoreException e) {
4782           PHPeclipsePlugin.log(e);
4783         }
4784        endBlock = SimpleCharStream.getPosition();
4785       try {
4786         jj_consume_token(ENDFOR);
4787       } catch (ParseException e) {
4788         errorMessage = "'endfor' expected";
4789         errorLevel   = ERROR;
4790         errorStart = SimpleCharStream.getPosition() - e.currentToken.next.image.length() + 1;
4791         errorEnd   = SimpleCharStream.getPosition() + 1;
4792         {if (true) throw e;}
4793       }
4794       try {
4795         jj_consume_token(SEMICOLON);
4796         Statement[] stmtsArray = new Statement[list.size()];
4797         list.toArray(stmtsArray);
4798         {if (true) return new ForStatement(initializations,condition,increments,new Block(stmtsArray,startBlock,endBlock),pos,SimpleCharStream.getPosition());}
4799       } catch (ParseException e) {
4800         errorMessage = "';' expected after 'endfor' keyword";
4801         errorLevel   = ERROR;
4802         errorStart = SimpleCharStream.getPosition() - e.currentToken.next.image.length() + 1;
4803         errorEnd   = SimpleCharStream.getPosition() + 1;
4804         {if (true) throw e;}
4805       }
4806       break;
4807     default:
4808       jj_la1[118] = jj_gen;
4809       jj_consume_token(-1);
4810       throw new ParseException();
4811     }
4812     throw new Error("Missing return statement in function");
4813   }
4814
4815   static final public Statement[] ForInit() throws ParseException {
4816   Statement[] statements;
4817     if (jj_2_8(2147483647)) {
4818       statements = LocalVariableDeclaration();
4819    {if (true) return statements;}
4820     } else {
4821       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
4822       case ARRAY:
4823       case NEW:
4824       case DOLLAR:
4825       case INCR:
4826       case DECR:
4827       case IDENTIFIER:
4828       case DOLLAR_ID:
4829         statements = StatementExpressionList();
4830    {if (true) return statements;}
4831         break;
4832       default:
4833         jj_la1[119] = jj_gen;
4834         jj_consume_token(-1);
4835         throw new ParseException();
4836       }
4837     }
4838     throw new Error("Missing return statement in function");
4839   }
4840
4841   static final public Statement[] StatementExpressionList() throws ParseException {
4842   final ArrayList list = new ArrayList();
4843   Statement expr;
4844     expr = StatementExpression();
4845                                   list.add(expr);
4846     label_39:
4847     while (true) {
4848       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
4849       case COMMA:
4850         ;
4851         break;
4852       default:
4853         jj_la1[120] = jj_gen;
4854         break label_39;
4855       }
4856       jj_consume_token(COMMA);
4857       StatementExpression();
4858                                   list.add(expr);
4859     }
4860   Statement[] stmtsArray = new Statement[list.size()];
4861   list.toArray(stmtsArray);
4862   {if (true) return stmtsArray;}
4863     throw new Error("Missing return statement in function");
4864   }
4865
4866   static final public Continue ContinueStatement() throws ParseException {
4867   Expression expr = null;
4868   final int pos = SimpleCharStream.getPosition();
4869     jj_consume_token(CONTINUE);
4870     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
4871     case ARRAY:
4872     case LIST:
4873     case PRINT:
4874     case NEW:
4875     case NULL:
4876     case TRUE:
4877     case FALSE:
4878     case AT:
4879     case DOLLAR:
4880     case BANG:
4881     case INCR:
4882     case DECR:
4883     case PLUS:
4884     case MINUS:
4885     case BIT_AND:
4886     case INTEGER_LITERAL:
4887     case FLOATING_POINT_LITERAL:
4888     case STRING_LITERAL:
4889     case IDENTIFIER:
4890     case LPAREN:
4891     case DOLLAR_ID:
4892       expr = Expression();
4893       break;
4894     default:
4895       jj_la1[121] = jj_gen;
4896       ;
4897     }
4898     try {
4899       jj_consume_token(SEMICOLON);
4900      {if (true) return new Continue(expr,pos,SimpleCharStream.getPosition());}
4901     } catch (ParseException e) {
4902     errorMessage = "';' expected after 'continue' statement";
4903     errorLevel   = ERROR;
4904     errorStart = SimpleCharStream.getPosition() - e.currentToken.next.image.length() + 1;
4905     errorEnd   = SimpleCharStream.getPosition() + 1;
4906     {if (true) throw e;}
4907     }
4908     throw new Error("Missing return statement in function");
4909   }
4910
4911   static final public ReturnStatement ReturnStatement() throws ParseException {
4912   Expression expr = null;
4913   final int pos = SimpleCharStream.getPosition();
4914     jj_consume_token(RETURN);
4915     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
4916     case ARRAY:
4917     case LIST:
4918     case PRINT:
4919     case NEW:
4920     case NULL:
4921     case TRUE:
4922     case FALSE:
4923     case AT:
4924     case DOLLAR:
4925     case BANG:
4926     case INCR:
4927     case DECR:
4928     case PLUS:
4929     case MINUS:
4930     case BIT_AND:
4931     case INTEGER_LITERAL:
4932     case FLOATING_POINT_LITERAL:
4933     case STRING_LITERAL:
4934     case IDENTIFIER:
4935     case LPAREN:
4936     case DOLLAR_ID:
4937       expr = Expression();
4938       break;
4939     default:
4940       jj_la1[122] = jj_gen;
4941       ;
4942     }
4943     try {
4944       jj_consume_token(SEMICOLON);
4945      {if (true) return new ReturnStatement(expr,pos,SimpleCharStream.getPosition());}
4946     } catch (ParseException e) {
4947     errorMessage = "';' expected after 'return' statement";
4948     errorLevel   = ERROR;
4949     errorStart = SimpleCharStream.getPosition() - e.currentToken.next.image.length() + 1;
4950     errorEnd   = SimpleCharStream.getPosition() + 1;
4951     {if (true) throw e;}
4952     }
4953     throw new Error("Missing return statement in function");
4954   }
4955
4956   static final private boolean jj_2_1(int xla) {
4957     jj_la = xla; jj_lastpos = jj_scanpos = token;
4958     boolean retval = !jj_3_1();
4959     jj_save(0, xla);
4960     return retval;
4961   }
4962
4963   static final private boolean jj_2_2(int xla) {
4964     jj_la = xla; jj_lastpos = jj_scanpos = token;
4965     boolean retval = !jj_3_2();
4966     jj_save(1, xla);
4967     return retval;
4968   }
4969
4970   static final private boolean jj_2_3(int xla) {
4971     jj_la = xla; jj_lastpos = jj_scanpos = token;
4972     boolean retval = !jj_3_3();
4973     jj_save(2, xla);
4974     return retval;
4975   }
4976
4977   static final private boolean jj_2_4(int xla) {
4978     jj_la = xla; jj_lastpos = jj_scanpos = token;
4979     boolean retval = !jj_3_4();
4980     jj_save(3, xla);
4981     return retval;
4982   }
4983
4984   static final private boolean jj_2_5(int xla) {
4985     jj_la = xla; jj_lastpos = jj_scanpos = token;
4986     boolean retval = !jj_3_5();
4987     jj_save(4, xla);
4988     return retval;
4989   }
4990
4991   static final private boolean jj_2_6(int xla) {
4992     jj_la = xla; jj_lastpos = jj_scanpos = token;
4993     boolean retval = !jj_3_6();
4994     jj_save(5, xla);
4995     return retval;
4996   }
4997
4998   static final private boolean jj_2_7(int xla) {
4999     jj_la = xla; jj_lastpos = jj_scanpos = token;
5000     boolean retval = !jj_3_7();
5001     jj_save(6, xla);
5002     return retval;
5003   }
5004
5005   static final private boolean jj_2_8(int xla) {
5006     jj_la = xla; jj_lastpos = jj_scanpos = token;
5007     boolean retval = !jj_3_8();
5008     jj_save(7, xla);
5009     return retval;
5010   }
5011
5012   static final private boolean jj_3R_83() {
5013     if (jj_scan_token(OBJECT)) return true;
5014     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5015     return false;
5016   }
5017
5018   static final private boolean jj_3R_82() {
5019     if (jj_scan_token(INTEGER)) return true;
5020     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5021     return false;
5022   }
5023
5024   static final private boolean jj_3R_44() {
5025     if (jj_scan_token(ARRAY)) return true;
5026     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5027     return false;
5028   }
5029
5030   static final private boolean jj_3R_184() {
5031     if (jj_scan_token(ARRAY)) return true;
5032     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5033     return false;
5034   }
5035
5036   static final private boolean jj_3R_81() {
5037     if (jj_scan_token(INT)) return true;
5038     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5039     return false;
5040   }
5041
5042   static final private boolean jj_3R_183() {
5043     if (jj_3R_52()) return true;
5044     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5045     return false;
5046   }
5047
5048   static final private boolean jj_3R_80() {
5049     if (jj_scan_token(FLOAT)) return true;
5050     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5051     return false;
5052   }
5053
5054   static final private boolean jj_3R_85() {
5055     if (jj_scan_token(LIST)) return true;
5056     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5057     if (jj_scan_token(LPAREN)) return true;
5058     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5059     Token xsp;
5060     xsp = jj_scanpos;
5061     if (jj_3R_99()) jj_scanpos = xsp;
5062     else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5063     while (true) {
5064       xsp = jj_scanpos;
5065       if (jj_3R_100()) { jj_scanpos = xsp; break; }
5066       if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5067     }
5068     if (jj_scan_token(RPAREN)) return true;
5069     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5070     xsp = jj_scanpos;
5071     if (jj_3R_101()) jj_scanpos = xsp;
5072     else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5073     return false;
5074   }
5075
5076   static final private boolean jj_3R_167() {
5077     if (jj_scan_token(LPAREN)) return true;
5078     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5079     Token xsp;
5080     xsp = jj_scanpos;
5081     if (jj_3R_183()) {
5082     jj_scanpos = xsp;
5083     if (jj_3R_184()) return true;
5084     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5085     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5086     if (jj_scan_token(RPAREN)) return true;
5087     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5088     if (jj_3R_139()) return true;
5089     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5090     return false;
5091   }
5092
5093   static final private boolean jj_3R_79() {
5094     if (jj_scan_token(DOUBLE)) return true;
5095     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5096     return false;
5097   }
5098
5099   static final private boolean jj_3R_43() {
5100     if (jj_3R_52()) return true;
5101     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5102     return false;
5103   }
5104
5105   static final private boolean jj_3R_78() {
5106     if (jj_scan_token(REAL)) return true;
5107     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5108     return false;
5109   }
5110
5111   static final private boolean jj_3R_77() {
5112     if (jj_scan_token(BOOLEAN)) return true;
5113     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5114     return false;
5115   }
5116
5117   static final private boolean jj_3R_84() {
5118     if (jj_scan_token(PRINT)) return true;
5119     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5120     if (jj_3R_45()) return true;
5121     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5122     return false;
5123   }
5124
5125   static final private boolean jj_3R_76() {
5126     if (jj_scan_token(BOOL)) return true;
5127     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5128     return false;
5129   }
5130
5131   static final private boolean jj_3_4() {
5132     if (jj_scan_token(LPAREN)) return true;
5133     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5134     Token xsp;
5135     xsp = jj_scanpos;
5136     if (jj_3R_43()) {
5137     jj_scanpos = xsp;
5138     if (jj_3R_44()) return true;
5139     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5140     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5141     if (jj_scan_token(RPAREN)) return true;
5142     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5143     return false;
5144   }
5145
5146   static final private boolean jj_3R_75() {
5147     if (jj_scan_token(STRING)) return true;
5148     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5149     return false;
5150   }
5151
5152   static final private boolean jj_3R_52() {
5153     Token xsp;
5154     xsp = jj_scanpos;
5155     if (jj_3R_75()) {
5156     jj_scanpos = xsp;
5157     if (jj_3R_76()) {
5158     jj_scanpos = xsp;
5159     if (jj_3R_77()) {
5160     jj_scanpos = xsp;
5161     if (jj_3R_78()) {
5162     jj_scanpos = xsp;
5163     if (jj_3R_79()) {
5164     jj_scanpos = xsp;
5165     if (jj_3R_80()) {
5166     jj_scanpos = xsp;
5167     if (jj_3R_81()) {
5168     jj_scanpos = xsp;
5169     if (jj_3R_82()) {
5170     jj_scanpos = xsp;
5171     if (jj_3R_83()) return true;
5172     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5173     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5174     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5175     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5176     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5177     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5178     } 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     return false;
5182   }
5183
5184   static final private boolean jj_3R_165() {
5185     if (jj_scan_token(LPAREN)) return true;
5186     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5187     if (jj_3R_45()) return true;
5188     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5189     if (jj_scan_token(RPAREN)) return true;
5190     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5191     return false;
5192   }
5193
5194   static final private boolean jj_3R_164() {
5195     if (jj_3R_169()) return true;
5196     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5197     return false;
5198   }
5199
5200   static final private boolean jj_3R_163() {
5201     if (jj_3R_168()) return true;
5202     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5203     return false;
5204   }
5205
5206   static final private boolean jj_3R_162() {
5207     if (jj_3R_167()) return true;
5208     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5209     return false;
5210   }
5211
5212   static final private boolean jj_3R_158() {
5213     Token xsp;
5214     xsp = jj_scanpos;
5215     if (jj_3R_161()) {
5216     jj_scanpos = xsp;
5217     if (jj_3R_162()) {
5218     jj_scanpos = xsp;
5219     if (jj_3R_163()) {
5220     jj_scanpos = xsp;
5221     if (jj_3R_164()) {
5222     jj_scanpos = xsp;
5223     if (jj_3R_165()) return true;
5224     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5225     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5226     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5227     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5228     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5229     return false;
5230   }
5231
5232   static final private boolean jj_3R_161() {
5233     if (jj_scan_token(BANG)) return true;
5234     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5235     if (jj_3R_139()) return true;
5236     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5237     return false;
5238   }
5239
5240   static final private boolean jj_3R_160() {
5241     if (jj_scan_token(DECR)) return true;
5242     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5243     return false;
5244   }
5245
5246   static final private boolean jj_3R_159() {
5247     if (jj_scan_token(INCR)) return true;
5248     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5249     return false;
5250   }
5251
5252   static final private boolean jj_3R_157() {
5253     Token xsp;
5254     xsp = jj_scanpos;
5255     if (jj_3R_159()) {
5256     jj_scanpos = xsp;
5257     if (jj_3R_160()) return true;
5258     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5259     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5260     if (jj_3R_166()) return true;
5261     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5262     return false;
5263   }
5264
5265   static final private boolean jj_3R_152() {
5266     if (jj_3R_158()) return true;
5267     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5268     return false;
5269   }
5270
5271   static final private boolean jj_3R_151() {
5272     if (jj_3R_157()) return true;
5273     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5274     return false;
5275   }
5276
5277   static final private boolean jj_3R_156() {
5278     if (jj_scan_token(MINUS)) return true;
5279     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5280     return false;
5281   }
5282
5283   static final private boolean jj_3R_155() {
5284     if (jj_scan_token(PLUS)) return true;
5285     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5286     return false;
5287   }
5288
5289   static final private boolean jj_3R_148() {
5290     Token xsp;
5291     xsp = jj_scanpos;
5292     if (jj_3R_150()) {
5293     jj_scanpos = xsp;
5294     if (jj_3R_151()) {
5295     jj_scanpos = xsp;
5296     if (jj_3R_152()) return true;
5297     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5298     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5299     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5300     return false;
5301   }
5302
5303   static final private boolean jj_3R_150() {
5304     Token xsp;
5305     xsp = jj_scanpos;
5306     if (jj_3R_155()) {
5307     jj_scanpos = xsp;
5308     if (jj_3R_156()) return true;
5309     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5310     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5311     if (jj_3R_139()) return true;
5312     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5313     return false;
5314   }
5315
5316   static final private boolean jj_3R_154() {
5317     if (jj_3R_148()) return true;
5318     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5319     return false;
5320   }
5321
5322   static final private boolean jj_3R_149() {
5323     Token xsp;
5324     xsp = jj_scanpos;
5325     if (jj_3R_153()) {
5326     jj_scanpos = xsp;
5327     if (jj_3R_154()) return true;
5328     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5329     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5330     return false;
5331   }
5332
5333   static final private boolean jj_3R_153() {
5334     if (jj_scan_token(AT)) return true;
5335     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5336     if (jj_3R_149()) return true;
5337     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5338     return false;
5339   }
5340
5341   static final private boolean jj_3R_144() {
5342     if (jj_3R_149()) return true;
5343     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5344     return false;
5345   }
5346
5347   static final private boolean jj_3R_139() {
5348     Token xsp;
5349     xsp = jj_scanpos;
5350     if (jj_3R_143()) {
5351     jj_scanpos = xsp;
5352     if (jj_3R_144()) return true;
5353     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5354     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5355     return false;
5356   }
5357
5358   static final private boolean jj_3R_143() {
5359     if (jj_scan_token(BIT_AND)) return true;
5360     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5361     if (jj_3R_148()) return true;
5362     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5363     return false;
5364   }
5365
5366   static final private boolean jj_3R_147() {
5367     if (jj_scan_token(REMAINDER)) return true;
5368     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5369     return false;
5370   }
5371
5372   static final private boolean jj_3R_146() {
5373     if (jj_scan_token(SLASH)) return true;
5374     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5375     return false;
5376   }
5377
5378   static final private boolean jj_3R_145() {
5379     if (jj_scan_token(STAR)) return true;
5380     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5381     return false;
5382   }
5383
5384   static final private boolean jj_3R_140() {
5385     Token xsp;
5386     xsp = jj_scanpos;
5387     if (jj_3R_145()) {
5388     jj_scanpos = xsp;
5389     if (jj_3R_146()) {
5390     jj_scanpos = xsp;
5391     if (jj_3R_147()) return true;
5392     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5393     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5394     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5395     if (jj_3R_139()) return true;
5396     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5397     return false;
5398   }
5399
5400   static final private boolean jj_3R_87() {
5401     if (jj_scan_token(ASSIGN)) return true;
5402     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5403     if (jj_3R_45()) return true;
5404     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5405     return false;
5406   }
5407
5408   static final private boolean jj_3R_134() {
5409     if (jj_3R_139()) return true;
5410     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5411     Token xsp;
5412     while (true) {
5413       xsp = jj_scanpos;
5414       if (jj_3R_140()) { jj_scanpos = xsp; break; }
5415       if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5416     }
5417     return false;
5418   }
5419
5420   static final private boolean jj_3R_142() {
5421     if (jj_scan_token(MINUS)) return true;
5422     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5423     return false;
5424   }
5425
5426   static final private boolean jj_3R_141() {
5427     if (jj_scan_token(PLUS)) return true;
5428     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5429     return false;
5430   }
5431
5432   static final private boolean jj_3R_135() {
5433     Token xsp;
5434     xsp = jj_scanpos;
5435     if (jj_3R_141()) {
5436     jj_scanpos = xsp;
5437     if (jj_3R_142()) return true;
5438     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5439     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5440     if (jj_3R_134()) return true;
5441     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5442     return false;
5443   }
5444
5445   static final private boolean jj_3R_128() {
5446     if (jj_3R_134()) return true;
5447     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5448     Token xsp;
5449     while (true) {
5450       xsp = jj_scanpos;
5451       if (jj_3R_135()) { jj_scanpos = xsp; break; }
5452       if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5453     }
5454     return false;
5455   }
5456
5457   static final private boolean jj_3R_198() {
5458     if (jj_scan_token(COMMA)) return true;
5459     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5460     return false;
5461   }
5462
5463   static final private boolean jj_3_7() {
5464     if (jj_3R_46()) return true;
5465     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5466     return false;
5467   }
5468
5469   static final private boolean jj_3_2() {
5470     if (jj_scan_token(COMMA)) return true;
5471     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5472     if (jj_3R_41()) return true;
5473     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5474     return false;
5475   }
5476
5477   static final private boolean jj_3R_197() {
5478     if (jj_3R_41()) return true;
5479     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5480     Token xsp;
5481     while (true) {
5482       xsp = jj_scanpos;
5483       if (jj_3_2()) { jj_scanpos = xsp; break; }
5484       if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5485     }
5486     return false;
5487   }
5488
5489   static final private boolean jj_3R_57() {
5490     if (jj_3R_50()) return true;
5491     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5492     Token xsp;
5493     xsp = jj_scanpos;
5494     if (jj_3R_87()) jj_scanpos = xsp;
5495     else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5496     return false;
5497   }
5498
5499   static final private boolean jj_3R_138() {
5500     if (jj_scan_token(RUNSIGNEDSHIFT)) return true;
5501     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5502     return false;
5503   }
5504
5505   static final private boolean jj_3R_137() {
5506     if (jj_scan_token(RSIGNEDSHIFT)) return true;
5507     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5508     return false;
5509   }
5510
5511   static final private boolean jj_3R_136() {
5512     if (jj_scan_token(LSHIFT)) return true;
5513     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5514     return false;
5515   }
5516
5517   static final private boolean jj_3R_129() {
5518     Token xsp;
5519     xsp = jj_scanpos;
5520     if (jj_3R_136()) {
5521     jj_scanpos = xsp;
5522     if (jj_3R_137()) {
5523     jj_scanpos = xsp;
5524     if (jj_3R_138()) return true;
5525     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5526     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5527     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5528     if (jj_3R_128()) return true;
5529     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5530     return false;
5531   }
5532
5533   static final private boolean jj_3R_121() {
5534     if (jj_3R_128()) return true;
5535     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5536     Token xsp;
5537     while (true) {
5538       xsp = jj_scanpos;
5539       if (jj_3R_129()) { jj_scanpos = xsp; break; }
5540       if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5541     }
5542     return false;
5543   }
5544
5545   static final private boolean jj_3_6() {
5546     if (jj_3R_45()) return true;
5547     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5548     if (jj_scan_token(SEMICOLON)) return true;
5549     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5550     return false;
5551   }
5552
5553   static final private boolean jj_3R_192() {
5554     if (jj_scan_token(LPAREN)) return true;
5555     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5556     Token xsp;
5557     xsp = jj_scanpos;
5558     if (jj_3R_197()) jj_scanpos = xsp;
5559     else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5560     xsp = jj_scanpos;
5561     if (jj_3R_198()) jj_scanpos = xsp;
5562     else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5563     if (jj_scan_token(RPAREN)) return true;
5564     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5565     return false;
5566   }
5567
5568   static final private boolean jj_3R_58() {
5569     if (jj_scan_token(COMMA)) return true;
5570     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5571     if (jj_3R_57()) return true;
5572     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5573     return false;
5574   }
5575
5576   static final private boolean jj_3R_47() {
5577     if (jj_3R_57()) return true;
5578     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5579     Token xsp;
5580     while (true) {
5581       xsp = jj_scanpos;
5582       if (jj_3R_58()) { jj_scanpos = xsp; break; }
5583       if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5584     }
5585     return false;
5586   }
5587
5588   static final private boolean jj_3R_133() {
5589     if (jj_scan_token(GE)) return true;
5590     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5591     return false;
5592   }
5593
5594   static final private boolean jj_3R_201() {
5595     if (jj_scan_token(ARRAYASSIGN)) return true;
5596     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5597     if (jj_3R_45()) return true;
5598     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5599     return false;
5600   }
5601
5602   static final private boolean jj_3R_132() {
5603     if (jj_scan_token(LE)) return true;
5604     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5605     return false;
5606   }
5607
5608   static final private boolean jj_3R_131() {
5609     if (jj_scan_token(GT)) return true;
5610     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5611     return false;
5612   }
5613
5614   static final private boolean jj_3R_41() {
5615     if (jj_3R_45()) return true;
5616     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5617     Token xsp;
5618     xsp = jj_scanpos;
5619     if (jj_3R_201()) jj_scanpos = xsp;
5620     else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5621     return false;
5622   }
5623
5624   static final private boolean jj_3R_130() {
5625     if (jj_scan_token(LT)) return true;
5626     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5627     return false;
5628   }
5629
5630   static final private boolean jj_3R_122() {
5631     Token xsp;
5632     xsp = jj_scanpos;
5633     if (jj_3R_130()) {
5634     jj_scanpos = xsp;
5635     if (jj_3R_131()) {
5636     jj_scanpos = xsp;
5637     if (jj_3R_132()) {
5638     jj_scanpos = xsp;
5639     if (jj_3R_133()) return true;
5640     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5641     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5642     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5643     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5644     if (jj_3R_121()) return true;
5645     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5646     return false;
5647   }
5648
5649   static final private boolean jj_3R_119() {
5650     if (jj_3R_121()) return true;
5651     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5652     Token xsp;
5653     while (true) {
5654       xsp = jj_scanpos;
5655       if (jj_3R_122()) { jj_scanpos = xsp; break; }
5656       if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5657     }
5658     return false;
5659   }
5660
5661   static final private boolean jj_3R_203() {
5662     if (jj_scan_token(COMMA)) return true;
5663     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5664     if (jj_3R_45()) return true;
5665     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5666     return false;
5667   }
5668
5669   static final private boolean jj_3R_202() {
5670     if (jj_3R_45()) return true;
5671     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5672     Token xsp;
5673     while (true) {
5674       xsp = jj_scanpos;
5675       if (jj_3R_203()) { jj_scanpos = xsp; break; }
5676       if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5677     }
5678     return false;
5679   }
5680
5681   static final private boolean jj_3R_127() {
5682     if (jj_scan_token(TRIPLEEQUAL)) return true;
5683     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5684     return false;
5685   }
5686
5687   static final private boolean jj_3R_200() {
5688     if (jj_3R_202()) return true;
5689     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5690     return false;
5691   }
5692
5693   static final private boolean jj_3R_126() {
5694     if (jj_scan_token(BANGDOUBLEEQUAL)) return true;
5695     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5696     return false;
5697   }
5698
5699   static final private boolean jj_3R_125() {
5700     if (jj_scan_token(NOT_EQUAL)) return true;
5701     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5702     return false;
5703   }
5704
5705   static final private boolean jj_3R_124() {
5706     if (jj_scan_token(DIF)) return true;
5707     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5708     return false;
5709   }
5710
5711   static final private boolean jj_3R_123() {
5712     if (jj_scan_token(EQUAL_EQUAL)) return true;
5713     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5714     return false;
5715   }
5716
5717   static final private boolean jj_3R_120() {
5718     Token xsp;
5719     xsp = jj_scanpos;
5720     if (jj_3R_123()) {
5721     jj_scanpos = xsp;
5722     if (jj_3R_124()) {
5723     jj_scanpos = xsp;
5724     if (jj_3R_125()) {
5725     jj_scanpos = xsp;
5726     if (jj_3R_126()) {
5727     jj_scanpos = xsp;
5728     if (jj_3R_127()) return true;
5729     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5730     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5731     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5732     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5733     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5734     if (jj_3R_119()) return true;
5735     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5736     return false;
5737   }
5738
5739   static final private boolean jj_3R_108() {
5740     if (jj_scan_token(LBRACE)) return true;
5741     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5742     if (jj_3R_45()) return true;
5743     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5744     if (jj_scan_token(RBRACE)) return true;
5745     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5746     return false;
5747   }
5748
5749   static final private boolean jj_3R_93() {
5750     if (jj_3R_52()) return true;
5751     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5752     return false;
5753   }
5754
5755   static final private boolean jj_3R_117() {
5756     if (jj_3R_119()) return true;
5757     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5758     Token xsp;
5759     while (true) {
5760       xsp = jj_scanpos;
5761       if (jj_3R_120()) { jj_scanpos = xsp; break; }
5762       if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5763     }
5764     return false;
5765   }
5766
5767   static final private boolean jj_3R_199() {
5768     if (jj_scan_token(LPAREN)) return true;
5769     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5770     Token xsp;
5771     xsp = jj_scanpos;
5772     if (jj_3R_200()) jj_scanpos = xsp;
5773     else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5774     if (jj_scan_token(RPAREN)) return true;
5775     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5776     return false;
5777   }
5778
5779   static final private boolean jj_3R_91() {
5780     if (jj_scan_token(DOLLAR_ID)) return true;
5781     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5782     return false;
5783   }
5784
5785   static final private boolean jj_3R_90() {
5786     if (jj_scan_token(DOLLAR)) return true;
5787     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5788     if (jj_3R_59()) return true;
5789     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5790     return false;
5791   }
5792
5793   static final private boolean jj_3R_118() {
5794     if (jj_scan_token(BIT_AND)) return true;
5795     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5796     if (jj_3R_117()) return true;
5797     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5798     return false;
5799   }
5800
5801   static final private boolean jj_3R_177() {
5802     if (jj_scan_token(NULL)) return true;
5803     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5804     return false;
5805   }
5806
5807   static final private boolean jj_3R_176() {
5808     if (jj_scan_token(FALSE)) return true;
5809     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5810     return false;
5811   }
5812
5813   static final private boolean jj_3R_115() {
5814     if (jj_3R_117()) return true;
5815     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5816     Token xsp;
5817     while (true) {
5818       xsp = jj_scanpos;
5819       if (jj_3R_118()) { jj_scanpos = xsp; break; }
5820       if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5821     }
5822     return false;
5823   }
5824
5825   static final private boolean jj_3R_175() {
5826     if (jj_scan_token(TRUE)) return true;
5827     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5828     return false;
5829   }
5830
5831   static final private boolean jj_3R_174() {
5832     if (jj_scan_token(STRING_LITERAL)) return true;
5833     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5834     return false;
5835   }
5836
5837   static final private boolean jj_3R_173() {
5838     if (jj_scan_token(FLOATING_POINT_LITERAL)) return true;
5839     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5840     return false;
5841   }
5842
5843   static final private boolean jj_3R_89() {
5844     if (jj_scan_token(IDENTIFIER)) return true;
5845     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5846     Token xsp;
5847     xsp = jj_scanpos;
5848     if (jj_3R_108()) jj_scanpos = xsp;
5849     else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5850     return false;
5851   }
5852
5853   static final private boolean jj_3R_169() {
5854     Token xsp;
5855     xsp = jj_scanpos;
5856     if (jj_3R_172()) {
5857     jj_scanpos = xsp;
5858     if (jj_3R_173()) {
5859     jj_scanpos = xsp;
5860     if (jj_3R_174()) {
5861     jj_scanpos = xsp;
5862     if (jj_3R_175()) {
5863     jj_scanpos = xsp;
5864     if (jj_3R_176()) {
5865     jj_scanpos = xsp;
5866     if (jj_3R_177()) return true;
5867     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5868     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5869     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5870     } else 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     return false;
5874   }
5875
5876   static final private boolean jj_3R_172() {
5877     if (jj_scan_token(INTEGER_LITERAL)) return true;
5878     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5879     return false;
5880   }
5881
5882   static final private boolean jj_3R_116() {
5883     if (jj_scan_token(XOR)) return true;
5884     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5885     if (jj_3R_115()) return true;
5886     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5887     return false;
5888   }
5889
5890   static final private boolean jj_3R_88() {
5891     if (jj_scan_token(LBRACE)) return true;
5892     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5893     if (jj_3R_45()) return true;
5894     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5895     if (jj_scan_token(RBRACE)) return true;
5896     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5897     return false;
5898   }
5899
5900   static final private boolean jj_3R_59() {
5901     Token xsp;
5902     xsp = jj_scanpos;
5903     if (jj_3R_88()) {
5904     jj_scanpos = xsp;
5905     if (jj_3R_89()) {
5906     jj_scanpos = xsp;
5907     if (jj_3R_90()) {
5908     jj_scanpos = xsp;
5909     if (jj_3R_91()) return true;
5910     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5911     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5912     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5913     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5914     return false;
5915   }
5916
5917   static final private boolean jj_3R_113() {
5918     if (jj_3R_115()) return true;
5919     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5920     Token xsp;
5921     while (true) {
5922       xsp = jj_scanpos;
5923       if (jj_3R_116()) { jj_scanpos = xsp; break; }
5924       if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5925     }
5926     return false;
5927   }
5928
5929   static final private boolean jj_3R_92() {
5930     if (jj_3R_45()) return true;
5931     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5932     return false;
5933   }
5934
5935   static final private boolean jj_3R_60() {
5936     Token xsp;
5937     xsp = jj_scanpos;
5938     if (jj_3R_92()) {
5939     jj_scanpos = xsp;
5940     if (jj_3R_93()) return true;
5941     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5942     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5943     return false;
5944   }
5945
5946   static final private boolean jj_3R_98() {
5947     if (jj_scan_token(LBRACE)) return true;
5948     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5949     if (jj_3R_45()) return true;
5950     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5951     if (jj_scan_token(RBRACE)) return true;
5952     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5953     return false;
5954   }
5955
5956   static final private boolean jj_3R_46() {
5957     if (jj_scan_token(IDENTIFIER)) return true;
5958     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5959     if (jj_scan_token(COLON)) return true;
5960     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5961     return false;
5962   }
5963
5964   static final private boolean jj_3R_114() {
5965     if (jj_scan_token(BIT_OR)) return true;
5966     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5967     if (jj_3R_113()) return true;
5968     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5969     return false;
5970   }
5971
5972   static final private boolean jj_3R_95() {
5973     if (jj_scan_token(DOLLAR)) return true;
5974     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5975     if (jj_3R_59()) return true;
5976     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5977     return false;
5978   }
5979
5980   static final private boolean jj_3R_109() {
5981     if (jj_3R_113()) return true;
5982     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5983     Token xsp;
5984     while (true) {
5985       xsp = jj_scanpos;
5986       if (jj_3R_114()) { jj_scanpos = xsp; break; }
5987       if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5988     }
5989     return false;
5990   }
5991
5992   static final private boolean jj_3R_49() {
5993     if (jj_scan_token(LBRACKET)) return true;
5994     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5995     Token xsp;
5996     xsp = jj_scanpos;
5997     if (jj_3R_60()) jj_scanpos = xsp;
5998     else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5999     if (jj_scan_token(RBRACKET)) return true;
6000     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6001     return false;
6002   }
6003
6004   static final private boolean jj_3_8() {
6005     if (jj_3R_47()) return true;
6006     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6007     return false;
6008   }
6009
6010   static final private boolean jj_3R_110() {
6011     if (jj_scan_token(DOT)) return true;
6012     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6013     if (jj_3R_109()) return true;
6014     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6015     return false;
6016   }
6017
6018   static final private boolean jj_3R_94() {
6019     if (jj_scan_token(DOLLAR_ID)) return true;
6020     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6021     Token xsp;
6022     xsp = jj_scanpos;
6023     if (jj_3R_98()) jj_scanpos = xsp;
6024     else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6025     return false;
6026   }
6027
6028   static final private boolean jj_3R_61() {
6029     Token xsp;
6030     xsp = jj_scanpos;
6031     if (jj_3R_94()) {
6032     jj_scanpos = xsp;
6033     if (jj_3R_95()) return true;
6034     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6035     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6036     return false;
6037   }
6038
6039   static final private boolean jj_3R_104() {
6040     if (jj_3R_109()) return true;
6041     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6042     Token xsp;
6043     while (true) {
6044       xsp = jj_scanpos;
6045       if (jj_3R_110()) { jj_scanpos = xsp; break; }
6046       if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6047     }
6048     return false;
6049   }
6050
6051   static final private boolean jj_3R_48() {
6052     if (jj_scan_token(CLASSACCESS)) return true;
6053     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6054     if (jj_3R_59()) return true;
6055     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6056     return false;
6057   }
6058
6059   static final private boolean jj_3R_40() {
6060     Token xsp;
6061     xsp = jj_scanpos;
6062     if (jj_3R_48()) {
6063     jj_scanpos = xsp;
6064     if (jj_3R_49()) return true;
6065     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6066     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6067     return false;
6068   }
6069
6070   static final private boolean jj_3R_112() {
6071     if (jj_scan_token(_ANDL)) return true;
6072     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6073     return false;
6074   }
6075
6076   static final private boolean jj_3R_111() {
6077     if (jj_scan_token(AND_AND)) return true;
6078     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6079     return false;
6080   }
6081
6082   static final private boolean jj_3R_196() {
6083     if (jj_3R_40()) return true;
6084     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6085     return false;
6086   }
6087
6088   static final private boolean jj_3R_105() {
6089     Token xsp;
6090     xsp = jj_scanpos;
6091     if (jj_3R_111()) {
6092     jj_scanpos = xsp;
6093     if (jj_3R_112()) return true;
6094     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6095     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6096     if (jj_3R_104()) return true;
6097     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6098     return false;
6099   }
6100
6101   static final private boolean jj_3R_195() {
6102     if (jj_3R_199()) return true;
6103     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6104     return false;
6105   }
6106
6107   static final private boolean jj_3R_188() {
6108     Token xsp;
6109     xsp = jj_scanpos;
6110     if (jj_3R_195()) {
6111     jj_scanpos = xsp;
6112     if (jj_3R_196()) return true;
6113     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6114     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6115     return false;
6116   }
6117
6118   static final private boolean jj_3R_97() {
6119     if (jj_scan_token(HOOK)) return true;
6120     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6121     if (jj_3R_45()) return true;
6122     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6123     if (jj_scan_token(COLON)) return true;
6124     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6125     if (jj_3R_86()) return true;
6126     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6127     return false;
6128   }
6129
6130   static final private boolean jj_3R_102() {
6131     if (jj_3R_104()) return true;
6132     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6133     Token xsp;
6134     while (true) {
6135       xsp = jj_scanpos;
6136       if (jj_3R_105()) { jj_scanpos = xsp; break; }
6137       if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6138     }
6139     return false;
6140   }
6141
6142   static final private boolean jj_3_1() {
6143     if (jj_3R_40()) return true;
6144     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6145     return false;
6146   }
6147
6148   static final private boolean jj_3R_187() {
6149     if (jj_3R_50()) return true;
6150     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6151     return false;
6152   }
6153
6154   static final private boolean jj_3R_107() {
6155     if (jj_scan_token(_ORL)) return true;
6156     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6157     return false;
6158   }
6159
6160   static final private boolean jj_3R_106() {
6161     if (jj_scan_token(OR_OR)) return true;
6162     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6163     return false;
6164   }
6165
6166   static final private boolean jj_3R_186() {
6167     if (jj_scan_token(IDENTIFIER)) return true;
6168     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6169     return false;
6170   }
6171
6172   static final private boolean jj_3R_178() {
6173     Token xsp;
6174     xsp = jj_scanpos;
6175     if (jj_3R_186()) {
6176     jj_scanpos = xsp;
6177     if (jj_3R_187()) return true;
6178     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6179     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6180     return false;
6181   }
6182
6183   static final private boolean jj_3R_50() {
6184     if (jj_3R_61()) return true;
6185     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6186     Token xsp;
6187     while (true) {
6188       xsp = jj_scanpos;
6189       if (jj_3_1()) { jj_scanpos = xsp; break; }
6190       if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6191     }
6192     return false;
6193   }
6194
6195   static final private boolean jj_3R_103() {
6196     Token xsp;
6197     xsp = jj_scanpos;
6198     if (jj_3R_106()) {
6199     jj_scanpos = xsp;
6200     if (jj_3R_107()) return true;
6201     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6202     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6203     if (jj_3R_102()) return true;
6204     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6205     return false;
6206   }
6207
6208   static final private boolean jj_3R_96() {
6209     if (jj_3R_102()) return true;
6210     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6211     Token xsp;
6212     while (true) {
6213       xsp = jj_scanpos;
6214       if (jj_3R_103()) { jj_scanpos = xsp; break; }
6215       if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6216     }
6217     return false;
6218   }
6219
6220   static final private boolean jj_3R_86() {
6221     if (jj_3R_96()) return true;
6222     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6223     Token xsp;
6224     xsp = jj_scanpos;
6225     if (jj_3R_97()) jj_scanpos = xsp;
6226     else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6227     return false;
6228   }
6229
6230   static final private boolean jj_3R_74() {
6231     if (jj_scan_token(TILDEEQUAL)) return true;
6232     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6233     return false;
6234   }
6235
6236   static final private boolean jj_3R_191() {
6237     if (jj_3R_50()) return true;
6238     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6239     return false;
6240   }
6241
6242   static final private boolean jj_3R_73() {
6243     if (jj_scan_token(DOTASSIGN)) return true;
6244     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6245     return false;
6246   }
6247
6248   static final private boolean jj_3R_72() {
6249     if (jj_scan_token(ORASSIGN)) return true;
6250     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6251     return false;
6252   }
6253
6254   static final private boolean jj_3R_71() {
6255     if (jj_scan_token(XORASSIGN)) return true;
6256     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6257     return false;
6258   }
6259
6260   static final private boolean jj_3R_190() {
6261     if (jj_scan_token(NEW)) return true;
6262     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6263     if (jj_3R_178()) return true;
6264     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6265     return false;
6266   }
6267
6268   static final private boolean jj_3R_70() {
6269     if (jj_scan_token(ANDASSIGN)) return true;
6270     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6271     return false;
6272   }
6273
6274   static final private boolean jj_3R_69() {
6275     if (jj_scan_token(RSIGNEDSHIFTASSIGN)) return true;
6276     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6277     return false;
6278   }
6279
6280   static final private boolean jj_3R_68() {
6281     if (jj_scan_token(LSHIFTASSIGN)) return true;
6282     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6283     return false;
6284   }
6285
6286   static final private boolean jj_3R_189() {
6287     if (jj_scan_token(IDENTIFIER)) return true;
6288     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6289     return false;
6290   }
6291
6292   static final private boolean jj_3R_180() {
6293     Token xsp;
6294     xsp = jj_scanpos;
6295     if (jj_3R_189()) {
6296     jj_scanpos = xsp;
6297     if (jj_3R_190()) {
6298     jj_scanpos = xsp;
6299     if (jj_3R_191()) return true;
6300     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6301     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6302     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6303     return false;
6304   }
6305
6306   static final private boolean jj_3R_67() {
6307     if (jj_scan_token(MINUSASSIGN)) return true;
6308     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6309     return false;
6310   }
6311
6312   static final private boolean jj_3R_66() {
6313     if (jj_scan_token(PLUSASSIGN)) return true;
6314     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6315     return false;
6316   }
6317
6318   static final private boolean jj_3R_65() {
6319     if (jj_scan_token(REMASSIGN)) return true;
6320     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6321     return false;
6322   }
6323
6324   static final private boolean jj_3R_64() {
6325     if (jj_scan_token(SLASHASSIGN)) return true;
6326     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6327     return false;
6328   }
6329
6330   static final private boolean jj_3R_63() {
6331     if (jj_scan_token(STARASSIGN)) return true;
6332     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6333     return false;
6334   }
6335
6336   static final private boolean jj_3R_51() {
6337     Token xsp;
6338     xsp = jj_scanpos;
6339     if (jj_3R_62()) {
6340     jj_scanpos = xsp;
6341     if (jj_3R_63()) {
6342     jj_scanpos = xsp;
6343     if (jj_3R_64()) {
6344     jj_scanpos = xsp;
6345     if (jj_3R_65()) {
6346     jj_scanpos = xsp;
6347     if (jj_3R_66()) {
6348     jj_scanpos = xsp;
6349     if (jj_3R_67()) {
6350     jj_scanpos = xsp;
6351     if (jj_3R_68()) {
6352     jj_scanpos = xsp;
6353     if (jj_3R_69()) {
6354     jj_scanpos = xsp;
6355     if (jj_3R_70()) {
6356     jj_scanpos = xsp;
6357     if (jj_3R_71()) {
6358     jj_scanpos = xsp;
6359     if (jj_3R_72()) {
6360     jj_scanpos = xsp;
6361     if (jj_3R_73()) {
6362     jj_scanpos = xsp;
6363     if (jj_3R_74()) return true;
6364     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6365     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6366     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6367     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6368     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6369     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6370     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6371     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6372     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6373     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6374     } 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     return false;
6378   }
6379
6380   static final private boolean jj_3R_62() {
6381     if (jj_scan_token(ASSIGN)) return true;
6382     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6383     return false;
6384   }
6385
6386   static final private boolean jj_3R_182() {
6387     if (jj_scan_token(ARRAY)) return true;
6388     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6389     if (jj_3R_192()) return true;
6390     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6391     return false;
6392   }
6393
6394   static final private boolean jj_3R_171() {
6395     if (jj_3R_182()) return true;
6396     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6397     return false;
6398   }
6399
6400   static final private boolean jj_3R_181() {
6401     if (jj_3R_188()) return true;
6402     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6403     return false;
6404   }
6405
6406   static final private boolean jj_3R_170() {
6407     if (jj_3R_180()) return true;
6408     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6409     Token xsp;
6410     while (true) {
6411       xsp = jj_scanpos;
6412       if (jj_3R_181()) { jj_scanpos = xsp; break; }
6413       if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6414     }
6415     return false;
6416   }
6417
6418   static final private boolean jj_3R_179() {
6419     if (jj_3R_188()) return true;
6420     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6421     return false;
6422   }
6423
6424   static final private boolean jj_3R_101() {
6425     if (jj_scan_token(ASSIGN)) return true;
6426     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6427     if (jj_3R_45()) return true;
6428     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6429     return false;
6430   }
6431
6432   static final private boolean jj_3R_42() {
6433     if (jj_3R_50()) return true;
6434     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6435     if (jj_3R_51()) return true;
6436     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6437     if (jj_3R_45()) return true;
6438     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6439     return false;
6440   }
6441
6442   static final private boolean jj_3_3() {
6443     if (jj_3R_42()) return true;
6444     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6445     return false;
6446   }
6447
6448   static final private boolean jj_3_5() {
6449     if (jj_scan_token(IDENTIFIER)) return true;
6450     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6451     if (jj_scan_token(STATICCLASSACCESS)) return true;
6452     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6453     if (jj_3R_178()) return true;
6454     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6455     Token xsp;
6456     while (true) {
6457       xsp = jj_scanpos;
6458       if (jj_3R_179()) { jj_scanpos = xsp; break; }
6459       if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6460     }
6461     return false;
6462   }
6463
6464   static final private boolean jj_3R_166() {
6465     Token xsp;
6466     xsp = jj_scanpos;
6467     if (jj_3_5()) {
6468     jj_scanpos = xsp;
6469     if (jj_3R_170()) {
6470     jj_scanpos = xsp;
6471     if (jj_3R_171()) return true;
6472     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6473     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6474     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6475     return false;
6476   }
6477
6478   static final private boolean jj_3R_56() {
6479     if (jj_3R_86()) return true;
6480     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6481     return false;
6482   }
6483
6484   static final private boolean jj_3R_55() {
6485     if (jj_3R_42()) return true;
6486     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6487     return false;
6488   }
6489
6490   static final private boolean jj_3R_54() {
6491     if (jj_3R_85()) return true;
6492     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6493     return false;
6494   }
6495
6496   static final private boolean jj_3R_45() {
6497     Token xsp;
6498     xsp = jj_scanpos;
6499     if (jj_3R_53()) {
6500     jj_scanpos = xsp;
6501     if (jj_3R_54()) {
6502     jj_scanpos = xsp;
6503     if (jj_3R_55()) {
6504     jj_scanpos = xsp;
6505     if (jj_3R_56()) return true;
6506     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6507     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6508     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6509     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6510     return false;
6511   }
6512
6513   static final private boolean jj_3R_53() {
6514     if (jj_3R_84()) return true;
6515     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6516     return false;
6517   }
6518
6519   static final private boolean jj_3R_100() {
6520     if (jj_scan_token(COMMA)) return true;
6521     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6522     if (jj_3R_50()) return true;
6523     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6524     return false;
6525   }
6526
6527   static final private boolean jj_3R_194() {
6528     if (jj_scan_token(DECR)) return true;
6529     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6530     return false;
6531   }
6532
6533   static final private boolean jj_3R_193() {
6534     if (jj_scan_token(INCR)) return true;
6535     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6536     return false;
6537   }
6538
6539   static final private boolean jj_3R_185() {
6540     Token xsp;
6541     xsp = jj_scanpos;
6542     if (jj_3R_193()) {
6543     jj_scanpos = xsp;
6544     if (jj_3R_194()) return true;
6545     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6546     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6547     return false;
6548   }
6549
6550   static final private boolean jj_3R_168() {
6551     if (jj_3R_166()) return true;
6552     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6553     Token xsp;
6554     xsp = jj_scanpos;
6555     if (jj_3R_185()) jj_scanpos = xsp;
6556     else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6557     return false;
6558   }
6559
6560   static final private boolean jj_3R_99() {
6561     if (jj_3R_50()) return true;
6562     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6563     return false;
6564   }
6565
6566   static private boolean jj_initialized_once = false;
6567   static public PHPParserTokenManager token_source;
6568   static SimpleCharStream jj_input_stream;
6569   static public Token token, jj_nt;
6570   static private int jj_ntk;
6571   static private Token jj_scanpos, jj_lastpos;
6572   static private int jj_la;
6573   static public boolean lookingAhead = false;
6574   static private boolean jj_semLA;
6575   static private int jj_gen;
6576   static final private int[] jj_la1 = new int[123];
6577   static private int[] jj_la1_0;
6578   static private int[] jj_la1_1;
6579   static private int[] jj_la1_2;
6580   static private int[] jj_la1_3;
6581   static private int[] jj_la1_4;
6582   static {
6583       jj_la1_0();
6584       jj_la1_1();
6585       jj_la1_2();
6586       jj_la1_3();
6587       jj_la1_4();
6588    }
6589    private static void jj_la1_0() {
6590       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,};
6591    }
6592    private static void jj_la1_1() {
6593       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,};
6594    }
6595    private static void jj_la1_2() {
6596       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,};
6597    }
6598    private static void jj_la1_3() {
6599       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,};
6600    }
6601    private static void jj_la1_4() {
6602       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,};
6603    }
6604   static final private JJCalls[] jj_2_rtns = new JJCalls[8];
6605   static private boolean jj_rescan = false;
6606   static private int jj_gc = 0;
6607
6608   public PHPParser(java.io.InputStream stream) {
6609     if (jj_initialized_once) {
6610       System.out.println("ERROR: Second call to constructor of static parser.  You must");
6611       System.out.println("       either use ReInit() or set the JavaCC option STATIC to false");
6612       System.out.println("       during parser generation.");
6613       throw new Error();
6614     }
6615     jj_initialized_once = true;
6616     jj_input_stream = new SimpleCharStream(stream, 1, 1);
6617     token_source = new PHPParserTokenManager(jj_input_stream);
6618     token = new Token();
6619     jj_ntk = -1;
6620     jj_gen = 0;
6621     for (int i = 0; i < 123; i++) jj_la1[i] = -1;
6622     for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
6623   }
6624
6625   static public void ReInit(java.io.InputStream stream) {
6626     jj_input_stream.ReInit(stream, 1, 1);
6627     token_source.ReInit(jj_input_stream);
6628     token = new Token();
6629     jj_ntk = -1;
6630     jj_gen = 0;
6631     for (int i = 0; i < 123; i++) jj_la1[i] = -1;
6632     for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
6633   }
6634
6635   public PHPParser(java.io.Reader stream) {
6636     if (jj_initialized_once) {
6637       System.out.println("ERROR: Second call to constructor of static parser.  You must");
6638       System.out.println("       either use ReInit() or set the JavaCC option STATIC to false");
6639       System.out.println("       during parser generation.");
6640       throw new Error();
6641     }
6642     jj_initialized_once = true;
6643     jj_input_stream = new SimpleCharStream(stream, 1, 1);
6644     token_source = new PHPParserTokenManager(jj_input_stream);
6645     token = new Token();
6646     jj_ntk = -1;
6647     jj_gen = 0;
6648     for (int i = 0; i < 123; i++) jj_la1[i] = -1;
6649     for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
6650   }
6651
6652   static public void ReInit(java.io.Reader stream) {
6653     jj_input_stream.ReInit(stream, 1, 1);
6654     token_source.ReInit(jj_input_stream);
6655     token = new Token();
6656     jj_ntk = -1;
6657     jj_gen = 0;
6658     for (int i = 0; i < 123; i++) jj_la1[i] = -1;
6659     for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
6660   }
6661
6662   public PHPParser(PHPParserTokenManager tm) {
6663     if (jj_initialized_once) {
6664       System.out.println("ERROR: Second call to constructor of static parser.  You must");
6665       System.out.println("       either use ReInit() or set the JavaCC option STATIC to false");
6666       System.out.println("       during parser generation.");
6667       throw new Error();
6668     }
6669     jj_initialized_once = true;
6670     token_source = tm;
6671     token = new Token();
6672     jj_ntk = -1;
6673     jj_gen = 0;
6674     for (int i = 0; i < 123; i++) jj_la1[i] = -1;
6675     for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
6676   }
6677
6678   public void ReInit(PHPParserTokenManager tm) {
6679     token_source = tm;
6680     token = new Token();
6681     jj_ntk = -1;
6682     jj_gen = 0;
6683     for (int i = 0; i < 123; i++) jj_la1[i] = -1;
6684     for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
6685   }
6686
6687   static final private Token jj_consume_token(int kind) throws ParseException {
6688     Token oldToken;
6689     if ((oldToken = token).next != null) token = token.next;
6690     else token = token.next = token_source.getNextToken();
6691     jj_ntk = -1;
6692     if (token.kind == kind) {
6693       jj_gen++;
6694       if (++jj_gc > 100) {
6695         jj_gc = 0;
6696         for (int i = 0; i < jj_2_rtns.length; i++) {
6697           JJCalls c = jj_2_rtns[i];
6698           while (c != null) {
6699             if (c.gen < jj_gen) c.first = null;
6700             c = c.next;
6701           }
6702         }
6703       }
6704       return token;
6705     }
6706     token = oldToken;
6707     jj_kind = kind;
6708     throw generateParseException();
6709   }
6710
6711   static final private boolean jj_scan_token(int kind) {
6712     if (jj_scanpos == jj_lastpos) {
6713       jj_la--;
6714       if (jj_scanpos.next == null) {
6715         jj_lastpos = jj_scanpos = jj_scanpos.next = token_source.getNextToken();
6716       } else {
6717         jj_lastpos = jj_scanpos = jj_scanpos.next;
6718       }
6719     } else {
6720       jj_scanpos = jj_scanpos.next;
6721     }
6722     if (jj_rescan) {
6723       int i = 0; Token tok = token;
6724       while (tok != null && tok != jj_scanpos) { i++; tok = tok.next; }
6725       if (tok != null) jj_add_error_token(kind, i);
6726     }
6727     return (jj_scanpos.kind != kind);
6728   }
6729
6730   static final public Token getNextToken() {
6731     if (token.next != null) token = token.next;
6732     else token = token.next = token_source.getNextToken();
6733     jj_ntk = -1;
6734     jj_gen++;
6735     return token;
6736   }
6737
6738   static final public Token getToken(int index) {
6739     Token t = lookingAhead ? jj_scanpos : token;
6740     for (int i = 0; i < index; i++) {
6741       if (t.next != null) t = t.next;
6742       else t = t.next = token_source.getNextToken();
6743     }
6744     return t;
6745   }
6746
6747   static final private int jj_ntk() {
6748     if ((jj_nt=token.next) == null)
6749       return (jj_ntk = (token.next=token_source.getNextToken()).kind);
6750     else
6751       return (jj_ntk = jj_nt.kind);
6752   }
6753
6754   static private java.util.Vector jj_expentries = new java.util.Vector();
6755   static private int[] jj_expentry;
6756   static private int jj_kind = -1;
6757   static private int[] jj_lasttokens = new int[100];
6758   static private int jj_endpos;
6759
6760   static private void jj_add_error_token(int kind, int pos) {
6761     if (pos >= 100) return;
6762     if (pos == jj_endpos + 1) {
6763       jj_lasttokens[jj_endpos++] = kind;
6764     } else if (jj_endpos != 0) {
6765       jj_expentry = new int[jj_endpos];
6766       for (int i = 0; i < jj_endpos; i++) {
6767         jj_expentry[i] = jj_lasttokens[i];
6768       }
6769       boolean exists = false;
6770       for (java.util.Enumeration enum = jj_expentries.elements(); enum.hasMoreElements();) {
6771         int[] oldentry = (int[])(enum.nextElement());
6772         if (oldentry.length == jj_expentry.length) {
6773           exists = true;
6774           for (int i = 0; i < jj_expentry.length; i++) {
6775             if (oldentry[i] != jj_expentry[i]) {
6776               exists = false;
6777               break;
6778             }
6779           }
6780           if (exists) break;
6781         }
6782       }
6783       if (!exists) jj_expentries.addElement(jj_expentry);
6784       if (pos != 0) jj_lasttokens[(jj_endpos = pos) - 1] = kind;
6785     }
6786   }
6787
6788   static public ParseException generateParseException() {
6789     jj_expentries.removeAllElements();
6790     boolean[] la1tokens = new boolean[141];
6791     for (int i = 0; i < 141; i++) {
6792       la1tokens[i] = false;
6793     }
6794     if (jj_kind >= 0) {
6795       la1tokens[jj_kind] = true;
6796       jj_kind = -1;
6797     }
6798     for (int i = 0; i < 123; i++) {
6799       if (jj_la1[i] == jj_gen) {
6800         for (int j = 0; j < 32; j++) {
6801           if ((jj_la1_0[i] & (1<<j)) != 0) {
6802             la1tokens[j] = true;
6803           }
6804           if ((jj_la1_1[i] & (1<<j)) != 0) {
6805             la1tokens[32+j] = true;
6806           }
6807           if ((jj_la1_2[i] & (1<<j)) != 0) {
6808             la1tokens[64+j] = true;
6809           }
6810           if ((jj_la1_3[i] & (1<<j)) != 0) {
6811             la1tokens[96+j] = true;
6812           }
6813           if ((jj_la1_4[i] & (1<<j)) != 0) {
6814             la1tokens[128+j] = true;
6815           }
6816         }
6817       }
6818     }
6819     for (int i = 0; i < 141; i++) {
6820       if (la1tokens[i]) {
6821         jj_expentry = new int[1];
6822         jj_expentry[0] = i;
6823         jj_expentries.addElement(jj_expentry);
6824       }
6825     }
6826     jj_endpos = 0;
6827     jj_rescan_token();
6828     jj_add_error_token(0, 0);
6829     int[][] exptokseq = new int[jj_expentries.size()][];
6830     for (int i = 0; i < jj_expentries.size(); i++) {
6831       exptokseq[i] = (int[])jj_expentries.elementAt(i);
6832     }
6833     return new ParseException(token, exptokseq, tokenImage);
6834   }
6835
6836   static final public void enable_tracing() {
6837   }
6838
6839   static final public void disable_tracing() {
6840   }
6841
6842   static final private void jj_rescan_token() {
6843     jj_rescan = true;
6844     for (int i = 0; i < 8; i++) {
6845       JJCalls p = jj_2_rtns[i];
6846       do {
6847         if (p.gen > jj_gen) {
6848           jj_la = p.arg; jj_lastpos = jj_scanpos = p.first;
6849           switch (i) {
6850             case 0: jj_3_1(); break;
6851             case 1: jj_3_2(); break;
6852             case 2: jj_3_3(); break;
6853             case 3: jj_3_4(); break;
6854             case 4: jj_3_5(); break;
6855             case 5: jj_3_6(); break;
6856             case 6: jj_3_7(); break;
6857             case 7: jj_3_8(); break;
6858           }
6859         }
6860         p = p.next;
6861       } while (p != null);
6862     }
6863     jj_rescan = false;
6864   }
6865
6866   static final private void jj_save(int index, int xla) {
6867     JJCalls p = jj_2_rtns[index];
6868     while (p.gen > jj_gen) {
6869       if (p.next == null) { p = p.next = new JJCalls(); break; }
6870       p = p.next;
6871     }
6872     p.gen = jj_gen + xla - jj_la; p.first = token; p.arg = xla;
6873   }
6874
6875   static final class JJCalls {
6876     int gen;
6877     Token first;
6878     int arg;
6879     JJCalls next;
6880   }
6881
6882 }