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