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