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