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                                    varName.image.substring(1).toCharArray(),
 728                                    pos,
 729                                    SimpleCharStream.getPosition());}
 730   }
 731   {if (true) return new VariableDeclaration(currentSegment,
 732                                  varName.image.substring(1).toCharArray(),
 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                                   varName.toCharArray(),
 764                                   pos,
 765                                   SimpleCharStream.getPosition());}
 766   }
 767     {if (true) return new VariableDeclaration(currentSegment,
 768                                     varName.toCharArray(),
 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     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1267     case ARRAY:
1268     case NEW:
1269     case NULL:
1270     case TRUE:
1271     case FALSE:
1272     case AT:
1273     case PLUS_PLUS:
1274     case MINUS_MINUS:
1275     case PLUS:
1276     case MINUS:
1277     case BIT_AND:
1278     case INTEGER_LITERAL:
1279     case FLOATING_POINT_LITERAL:
1280     case STRING_LITERAL:
1281     case IDENTIFIER:
1282     case LPAREN:
1283       expr = ConditionalExpression();
1284                                   {if (true) return expr;}
1285       break;
1286     case LIST:
1287     case PRINT:
1288     case DOLLAR:
1289     case BANG:
1290     case DOLLAR_ID:
1291       expr = ExpressionWBang();
1292                                   {if (true) return expr;}
1293       break;
1294     default:
1295       jj_la1[27] = jj_gen;
1296       jj_consume_token(-1);
1297       throw new ParseException();
1298     }
1299     throw new Error("Missing return statement in function");
1300   }
1301
1302   static final public Expression ExpressionWBang() throws ParseException {
1303   final Expression expr;
1304   final int pos = SimpleCharStream.getPosition();
1305     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1306     case BANG:
1307       jj_consume_token(BANG);
1308       expr = ExpressionWBang();
1309                                    {if (true) return new PrefixedUnaryExpression(expr,OperatorIds.NOT,pos);}
1310       break;
1311     case LIST:
1312     case PRINT:
1313     case DOLLAR:
1314     case DOLLAR_ID:
1315       expr = ExpressionNoBang();
1316                              {if (true) return expr;}
1317       break;
1318     default:
1319       jj_la1[28] = jj_gen;
1320       jj_consume_token(-1);
1321       throw new ParseException();
1322     }
1323     throw new Error("Missing return statement in function");
1324   }
1325
1326   static final public Expression ExpressionNoBang() throws ParseException {
1327   Expression expr = null;
1328   int assignOperator = -1;
1329   String var;
1330   final int pos = SimpleCharStream.getPosition();
1331     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1332     case PRINT:
1333       expr = PrintExpression();
1334                               {if (true) return expr;}
1335       break;
1336     case LIST:
1337       expr = ListExpression();
1338                               {if (true) return expr;}
1339       break;
1340     case DOLLAR:
1341     case DOLLAR_ID:
1342       var = VariableDeclaratorId();
1343       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1344       case ASSIGN:
1345       case PLUSASSIGN:
1346       case MINUSASSIGN:
1347       case STARASSIGN:
1348       case SLASHASSIGN:
1349       case ANDASSIGN:
1350       case ORASSIGN:
1351       case XORASSIGN:
1352       case DOTASSIGN:
1353       case REMASSIGN:
1354       case TILDEEQUAL:
1355       case LSHIFTASSIGN:
1356       case RSIGNEDSHIFTASSIGN:
1357         assignOperator = AssignmentOperator();
1358         try {
1359           expr = Expression();
1360         } catch (ParseException e) {
1361       if (errorMessage != null) {
1362         {if (true) throw e;}
1363       }
1364       errorMessage = "unexpected token : '"+ e.currentToken.next.image +"', expression expected";
1365       errorLevel   = ERROR;
1366       errorEnd   = SimpleCharStream.getPosition();
1367       {if (true) throw e;}
1368         }
1369         break;
1370       default:
1371         jj_la1[29] = jj_gen;
1372         ;
1373       }
1374     if (assignOperator == -1) {
1375       {if (true) return new VariableDeclaration(currentSegment,
1376                                      var.toCharArray(),
1377                                      pos,
1378                                      SimpleCharStream.getPosition());}
1379     }
1380     {if (true) return new VariableDeclaration(currentSegment,
1381                                    var.toCharArray(),
1382                                    expr,
1383                                    assignOperator,
1384                                    pos);}
1385    {if (true) return expr;}
1386       break;
1387     default:
1388       jj_la1[30] = jj_gen;
1389       jj_consume_token(-1);
1390       throw new ParseException();
1391     }
1392     throw new Error("Missing return statement in function");
1393   }
1394
1395 /**
1396  * Any assignement operator.
1397  * @return the assignement operator id
1398  */
1399   static final public int AssignmentOperator() throws ParseException {
1400     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1401     case ASSIGN:
1402       jj_consume_token(ASSIGN);
1403                         {if (true) return VariableDeclaration.EQUAL;}
1404       break;
1405     case STARASSIGN:
1406       jj_consume_token(STARASSIGN);
1407                         {if (true) return VariableDeclaration.STAR_EQUAL;}
1408       break;
1409     case SLASHASSIGN:
1410       jj_consume_token(SLASHASSIGN);
1411                         {if (true) return VariableDeclaration.SLASH_EQUAL;}
1412       break;
1413     case REMASSIGN:
1414       jj_consume_token(REMASSIGN);
1415                         {if (true) return VariableDeclaration.REM_EQUAL;}
1416       break;
1417     case PLUSASSIGN:
1418       jj_consume_token(PLUSASSIGN);
1419                         {if (true) return VariableDeclaration.PLUS_EQUAL;}
1420       break;
1421     case MINUSASSIGN:
1422       jj_consume_token(MINUSASSIGN);
1423                         {if (true) return VariableDeclaration.MINUS_EQUAL;}
1424       break;
1425     case LSHIFTASSIGN:
1426       jj_consume_token(LSHIFTASSIGN);
1427                         {if (true) return VariableDeclaration.LSHIFT_EQUAL;}
1428       break;
1429     case RSIGNEDSHIFTASSIGN:
1430       jj_consume_token(RSIGNEDSHIFTASSIGN);
1431                         {if (true) return VariableDeclaration.RSIGNEDSHIFT_EQUAL;}
1432       break;
1433     case ANDASSIGN:
1434       jj_consume_token(ANDASSIGN);
1435                         {if (true) return VariableDeclaration.AND_EQUAL;}
1436       break;
1437     case XORASSIGN:
1438       jj_consume_token(XORASSIGN);
1439                         {if (true) return VariableDeclaration.XOR_EQUAL;}
1440       break;
1441     case ORASSIGN:
1442       jj_consume_token(ORASSIGN);
1443                         {if (true) return VariableDeclaration.OR_EQUAL;}
1444       break;
1445     case DOTASSIGN:
1446       jj_consume_token(DOTASSIGN);
1447                         {if (true) return VariableDeclaration.DOT_EQUAL;}
1448       break;
1449     case TILDEEQUAL:
1450       jj_consume_token(TILDEEQUAL);
1451                         {if (true) return VariableDeclaration.TILDE_EQUAL;}
1452       break;
1453     default:
1454       jj_la1[31] = jj_gen;
1455       jj_consume_token(-1);
1456       throw new ParseException();
1457     }
1458     throw new Error("Missing return statement in function");
1459   }
1460
1461   static final public Expression ConditionalExpression() throws ParseException {
1462   final Expression expr;
1463   Expression expr2 = null;
1464   Expression expr3 = null;
1465     expr = ConditionalOrExpression();
1466     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1467     case HOOK:
1468       jj_consume_token(HOOK);
1469       expr2 = Expression();
1470       jj_consume_token(COLON);
1471       expr3 = ConditionalExpression();
1472       break;
1473     default:
1474       jj_la1[32] = jj_gen;
1475       ;
1476     }
1477   if (expr3 == null) {
1478     {if (true) return expr;}
1479   }
1480   {if (true) return new ConditionalExpression(expr,expr2,expr3);}
1481     throw new Error("Missing return statement in function");
1482   }
1483
1484   static final public Expression ConditionalOrExpression() throws ParseException {
1485   Expression expr,expr2;
1486   int operator;
1487     expr = ConditionalAndExpression();
1488     label_8:
1489     while (true) {
1490       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1491       case OR_OR:
1492       case _ORL:
1493         ;
1494         break;
1495       default:
1496         jj_la1[33] = jj_gen;
1497         break label_8;
1498       }
1499       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1500       case OR_OR:
1501         jj_consume_token(OR_OR);
1502                  operator = OperatorIds.OR_OR;
1503         break;
1504       case _ORL:
1505         jj_consume_token(_ORL);
1506                  operator = OperatorIds.ORL;
1507         break;
1508       default:
1509         jj_la1[34] = jj_gen;
1510         jj_consume_token(-1);
1511         throw new ParseException();
1512       }
1513       expr2 = ConditionalAndExpression();
1514       expr = new BinaryExpression(expr,expr2,operator);
1515     }
1516    {if (true) return expr;}
1517     throw new Error("Missing return statement in function");
1518   }
1519
1520   static final public Expression ConditionalAndExpression() throws ParseException {
1521   Expression expr,expr2;
1522   int operator;
1523     expr = ConcatExpression();
1524     label_9:
1525     while (true) {
1526       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1527       case AND_AND:
1528       case _ANDL:
1529         ;
1530         break;
1531       default:
1532         jj_la1[35] = jj_gen;
1533         break label_9;
1534       }
1535       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1536       case AND_AND:
1537         jj_consume_token(AND_AND);
1538                 operator = OperatorIds.AND_AND;
1539         break;
1540       case _ANDL:
1541         jj_consume_token(_ANDL);
1542                 operator = OperatorIds.ANDL;
1543         break;
1544       default:
1545         jj_la1[36] = jj_gen;
1546         jj_consume_token(-1);
1547         throw new ParseException();
1548       }
1549       expr2 = ConcatExpression();
1550                                expr = new BinaryExpression(expr,expr2,operator);
1551     }
1552    {if (true) return expr;}
1553     throw new Error("Missing return statement in function");
1554   }
1555
1556   static final public Expression ConcatExpression() throws ParseException {
1557   Expression expr,expr2;
1558     expr = InclusiveOrExpression();
1559     label_10:
1560     while (true) {
1561       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1562       case DOT:
1563         ;
1564         break;
1565       default:
1566         jj_la1[37] = jj_gen;
1567         break label_10;
1568       }
1569       jj_consume_token(DOT);
1570       expr2 = InclusiveOrExpression();
1571      expr = new BinaryExpression(expr,expr2,OperatorIds.DOT);
1572     }
1573    {if (true) return expr;}
1574     throw new Error("Missing return statement in function");
1575   }
1576
1577   static final public Expression InclusiveOrExpression() throws ParseException {
1578   Expression expr,expr2;
1579     expr = ExclusiveOrExpression();
1580     label_11:
1581     while (true) {
1582       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1583       case BIT_OR:
1584         ;
1585         break;
1586       default:
1587         jj_la1[38] = jj_gen;
1588         break label_11;
1589       }
1590       jj_consume_token(BIT_OR);
1591       expr2 = ExclusiveOrExpression();
1592     expr = new BinaryExpression(expr,expr2,OperatorIds.OR);
1593     }
1594    {if (true) return expr;}
1595     throw new Error("Missing return statement in function");
1596   }
1597
1598   static final public Expression ExclusiveOrExpression() throws ParseException {
1599   Expression expr,expr2;
1600     expr = AndExpression();
1601     label_12:
1602     while (true) {
1603       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1604       case XOR:
1605         ;
1606         break;
1607       default:
1608         jj_la1[39] = jj_gen;
1609         break label_12;
1610       }
1611       jj_consume_token(XOR);
1612       expr2 = AndExpression();
1613      expr = new BinaryExpression(expr,expr2,OperatorIds.XOR);
1614     }
1615    {if (true) return expr;}
1616     throw new Error("Missing return statement in function");
1617   }
1618
1619   static final public Expression AndExpression() throws ParseException {
1620   Expression expr,expr2;
1621     expr = EqualityExpression();
1622     label_13:
1623     while (true) {
1624       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1625       case BIT_AND:
1626         ;
1627         break;
1628       default:
1629         jj_la1[40] = jj_gen;
1630         break label_13;
1631       }
1632       jj_consume_token(BIT_AND);
1633       expr2 = EqualityExpression();
1634      expr = new BinaryExpression(expr,expr2,OperatorIds.AND);
1635     }
1636    {if (true) return expr;}
1637     throw new Error("Missing return statement in function");
1638   }
1639
1640   static final public Expression EqualityExpression() throws ParseException {
1641   Expression expr,expr2;
1642   int operator;
1643     expr = RelationalExpression();
1644     label_14:
1645     while (true) {
1646       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1647       case EQUAL_EQUAL:
1648       case NOT_EQUAL:
1649       case DIF:
1650       case BANGDOUBLEEQUAL:
1651       case TRIPLEEQUAL:
1652         ;
1653         break;
1654       default:
1655         jj_la1[41] = jj_gen;
1656         break label_14;
1657       }
1658       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1659       case EQUAL_EQUAL:
1660         jj_consume_token(EQUAL_EQUAL);
1661                           operator = OperatorIds.EQUAL_EQUAL;
1662         break;
1663       case DIF:
1664         jj_consume_token(DIF);
1665                           operator = OperatorIds.DIF;
1666         break;
1667       case NOT_EQUAL:
1668         jj_consume_token(NOT_EQUAL);
1669                           operator = OperatorIds.DIF;
1670         break;
1671       case BANGDOUBLEEQUAL:
1672         jj_consume_token(BANGDOUBLEEQUAL);
1673                           operator = OperatorIds.BANG_EQUAL_EQUAL;
1674         break;
1675       case TRIPLEEQUAL:
1676         jj_consume_token(TRIPLEEQUAL);
1677                           operator = OperatorIds.EQUAL_EQUAL_EQUAL;
1678         break;
1679       default:
1680         jj_la1[42] = jj_gen;
1681         jj_consume_token(-1);
1682         throw new ParseException();
1683       }
1684       try {
1685         expr2 = RelationalExpression();
1686       } catch (ParseException e) {
1687     if (errorMessage != null) {
1688       {if (true) throw e;}
1689     }
1690     errorMessage = "unexpected token : '"+ e.currentToken.next.image +"', expression expected";
1691     errorLevel   = ERROR;
1692     errorStart = SimpleCharStream.getPosition() - e.currentToken.next.image.length() + 1;
1693     errorEnd   = SimpleCharStream.getPosition() + 1;
1694     {if (true) throw e;}
1695       }
1696     expr = new BinaryExpression(expr,expr2,operator);
1697     }
1698    {if (true) return expr;}
1699     throw new Error("Missing return statement in function");
1700   }
1701
1702   static final public Expression RelationalExpression() throws ParseException {
1703   Expression expr,expr2;
1704   int operator;
1705     expr = ShiftExpression();
1706     label_15:
1707     while (true) {
1708       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1709       case GT:
1710       case LT:
1711       case LE:
1712       case GE:
1713         ;
1714         break;
1715       default:
1716         jj_la1[43] = jj_gen;
1717         break label_15;
1718       }
1719       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1720       case LT:
1721         jj_consume_token(LT);
1722           operator = OperatorIds.LESS;
1723         break;
1724       case GT:
1725         jj_consume_token(GT);
1726           operator = OperatorIds.GREATER;
1727         break;
1728       case LE:
1729         jj_consume_token(LE);
1730           operator = OperatorIds.LESS_EQUAL;
1731         break;
1732       case GE:
1733         jj_consume_token(GE);
1734           operator = OperatorIds.GREATER_EQUAL;
1735         break;
1736       default:
1737         jj_la1[44] = jj_gen;
1738         jj_consume_token(-1);
1739         throw new ParseException();
1740       }
1741       expr2 = ShiftExpression();
1742    expr = new BinaryExpression(expr,expr2,operator);
1743     }
1744    {if (true) return expr;}
1745     throw new Error("Missing return statement in function");
1746   }
1747
1748   static final public Expression ShiftExpression() throws ParseException {
1749   Expression expr,expr2;
1750   int operator;
1751     expr = AdditiveExpression();
1752     label_16:
1753     while (true) {
1754       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1755       case LSHIFT:
1756       case RSIGNEDSHIFT:
1757       case RUNSIGNEDSHIFT:
1758         ;
1759         break;
1760       default:
1761         jj_la1[45] = jj_gen;
1762         break label_16;
1763       }
1764       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1765       case LSHIFT:
1766         jj_consume_token(LSHIFT);
1767                       operator = OperatorIds.LEFT_SHIFT;
1768         break;
1769       case RSIGNEDSHIFT:
1770         jj_consume_token(RSIGNEDSHIFT);
1771                       operator = OperatorIds.RIGHT_SHIFT;
1772         break;
1773       case RUNSIGNEDSHIFT:
1774         jj_consume_token(RUNSIGNEDSHIFT);
1775                       operator = OperatorIds.UNSIGNED_RIGHT_SHIFT;
1776         break;
1777       default:
1778         jj_la1[46] = jj_gen;
1779         jj_consume_token(-1);
1780         throw new ParseException();
1781       }
1782       expr2 = AdditiveExpression();
1783    expr = new BinaryExpression(expr,expr2,operator);
1784     }
1785    {if (true) return expr;}
1786     throw new Error("Missing return statement in function");
1787   }
1788
1789   static final public Expression AdditiveExpression() throws ParseException {
1790   Expression expr,expr2;
1791   int operator;
1792     expr = MultiplicativeExpression();
1793     label_17:
1794     while (true) {
1795       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1796       case PLUS:
1797       case MINUS:
1798         ;
1799         break;
1800       default:
1801         jj_la1[47] = jj_gen;
1802         break label_17;
1803       }
1804       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1805       case PLUS:
1806         jj_consume_token(PLUS);
1807               operator = OperatorIds.PLUS;
1808         break;
1809       case MINUS:
1810         jj_consume_token(MINUS);
1811               operator = OperatorIds.MINUS;
1812         break;
1813       default:
1814         jj_la1[48] = jj_gen;
1815         jj_consume_token(-1);
1816         throw new ParseException();
1817       }
1818       expr2 = MultiplicativeExpression();
1819    expr = new BinaryExpression(expr,expr2,operator);
1820     }
1821    {if (true) return expr;}
1822     throw new Error("Missing return statement in function");
1823   }
1824
1825   static final public Expression MultiplicativeExpression() throws ParseException {
1826   Expression expr,expr2;
1827   int operator;
1828     try {
1829       expr = UnaryExpression();
1830     } catch (ParseException e) {
1831     if (errorMessage != null) {if (true) throw e;}
1832     errorMessage = "unexpected token '"+e.currentToken.next.image+"'";
1833     errorLevel   = ERROR;
1834     errorStart = SimpleCharStream.getPosition() - e.currentToken.next.image.length() + 1;
1835     errorEnd   = SimpleCharStream.getPosition() + 1;
1836     {if (true) throw e;}
1837     }
1838     label_18:
1839     while (true) {
1840       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1841       case STAR:
1842       case SLASH:
1843       case REMAINDER:
1844         ;
1845         break;
1846       default:
1847         jj_la1[49] = jj_gen;
1848         break label_18;
1849       }
1850       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1851       case STAR:
1852         jj_consume_token(STAR);
1853                    operator = OperatorIds.MULTIPLY;
1854         break;
1855       case SLASH:
1856         jj_consume_token(SLASH);
1857                    operator = OperatorIds.DIVIDE;
1858         break;
1859       case REMAINDER:
1860         jj_consume_token(REMAINDER);
1861                    operator = OperatorIds.REMAINDER;
1862         break;
1863       default:
1864         jj_la1[50] = jj_gen;
1865         jj_consume_token(-1);
1866         throw new ParseException();
1867       }
1868       expr2 = UnaryExpression();
1869      expr = new BinaryExpression(expr,expr2,operator);
1870     }
1871    {if (true) return expr;}
1872     throw new Error("Missing return statement in function");
1873   }
1874
1875 /**
1876  * An unary expression starting with @, & or nothing
1877  */
1878   static final public Expression UnaryExpression() throws ParseException {
1879   final Expression expr;
1880   final int pos = SimpleCharStream.getPosition();
1881     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1882     case BIT_AND:
1883       jj_consume_token(BIT_AND);
1884       expr = UnaryExpressionNoPrefix();
1885    {if (true) return new PrefixedUnaryExpression(expr,OperatorIds.AND,pos);}
1886       break;
1887     case ARRAY:
1888     case NEW:
1889     case NULL:
1890     case TRUE:
1891     case FALSE:
1892     case AT:
1893     case PLUS_PLUS:
1894     case MINUS_MINUS:
1895     case PLUS:
1896     case MINUS:
1897     case INTEGER_LITERAL:
1898     case FLOATING_POINT_LITERAL:
1899     case STRING_LITERAL:
1900     case IDENTIFIER:
1901     case LPAREN:
1902       expr = AtUnaryExpression();
1903                               {if (true) return expr;}
1904       break;
1905     default:
1906       jj_la1[51] = jj_gen;
1907       jj_consume_token(-1);
1908       throw new ParseException();
1909     }
1910     throw new Error("Missing return statement in function");
1911   }
1912
1913   static final public Expression AtUnaryExpression() throws ParseException {
1914   final Expression expr;
1915   final int pos = SimpleCharStream.getPosition();
1916     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1917     case AT:
1918       jj_consume_token(AT);
1919       expr = AtUnaryExpression();
1920    {if (true) return new PrefixedUnaryExpression(expr,OperatorIds.AT,pos);}
1921       break;
1922     case ARRAY:
1923     case NEW:
1924     case NULL:
1925     case TRUE:
1926     case FALSE:
1927     case PLUS_PLUS:
1928     case MINUS_MINUS:
1929     case PLUS:
1930     case MINUS:
1931     case INTEGER_LITERAL:
1932     case FLOATING_POINT_LITERAL:
1933     case STRING_LITERAL:
1934     case IDENTIFIER:
1935     case LPAREN:
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 INTEGER_LITERAL:
1982     case FLOATING_POINT_LITERAL:
1983     case STRING_LITERAL:
1984     case IDENTIFIER:
1985     case LPAREN:
1986       expr = UnaryExpressionNotPlusMinus();
1987    {if (true) return expr;}
1988       break;
1989     default:
1990       jj_la1[54] = jj_gen;
1991       jj_consume_token(-1);
1992       throw new ParseException();
1993     }
1994     throw new Error("Missing return statement in function");
1995   }
1996
1997   static final public Expression PreIncDecExpression() throws ParseException {
1998 final Expression expr;
1999 final int operator;
2000   final int pos = SimpleCharStream.getPosition();
2001     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2002     case PLUS_PLUS:
2003       jj_consume_token(PLUS_PLUS);
2004                      operator = OperatorIds.PLUS_PLUS;
2005       break;
2006     case MINUS_MINUS:
2007       jj_consume_token(MINUS_MINUS);
2008                      operator = OperatorIds.MINUS_MINUS;
2009       break;
2010     default:
2011       jj_la1[55] = jj_gen;
2012       jj_consume_token(-1);
2013       throw new ParseException();
2014     }
2015     expr = PrimaryExpression();
2016    {if (true) return new PrefixedUnaryExpression(expr,operator,pos);}
2017     throw new Error("Missing return statement in function");
2018   }
2019
2020   static final public Expression UnaryExpressionNotPlusMinus() throws ParseException {
2021   final Expression expr;
2022   final int pos = SimpleCharStream.getPosition();
2023     if (jj_2_3(2147483647)) {
2024       expr = CastExpression();
2025                                    {if (true) return expr;}
2026     } else {
2027       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2028       case ARRAY:
2029       case NEW:
2030       case IDENTIFIER:
2031         expr = PostfixExpression();
2032                                    {if (true) return expr;}
2033         break;
2034       case NULL:
2035       case TRUE:
2036       case FALSE:
2037       case INTEGER_LITERAL:
2038       case FLOATING_POINT_LITERAL:
2039       case STRING_LITERAL:
2040         expr = Literal();
2041                                    {if (true) return expr;}
2042         break;
2043       case LPAREN:
2044         jj_consume_token(LPAREN);
2045         expr = Expression();
2046         try {
2047           jj_consume_token(RPAREN);
2048         } catch (ParseException e) {
2049     errorMessage = "')' expected";
2050     errorLevel   = ERROR;
2051     errorStart   = SimpleCharStream.getPosition() - e.currentToken.next.image.length() + 1;
2052     errorEnd     = SimpleCharStream.getPosition() + 1;
2053     {if (true) throw e;}
2054         }
2055    {if (true) return expr;}
2056         break;
2057       default:
2058         jj_la1[56] = jj_gen;
2059         jj_consume_token(-1);
2060         throw new ParseException();
2061       }
2062     }
2063     throw new Error("Missing return statement in function");
2064   }
2065
2066   static final public CastExpression CastExpression() throws ParseException {
2067 final ConstantIdentifier type;
2068 final Expression expr;
2069 final int pos = SimpleCharStream.getPosition();
2070     jj_consume_token(LPAREN);
2071     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2072     case STRING:
2073     case OBJECT:
2074     case BOOL:
2075     case BOOLEAN:
2076     case REAL:
2077     case DOUBLE:
2078     case FLOAT:
2079     case INT:
2080     case INTEGER:
2081       type = Type();
2082       break;
2083     case ARRAY:
2084       jj_consume_token(ARRAY);
2085                type = new ConstantIdentifier(Types.ARRAY,pos,SimpleCharStream.getPosition());
2086       break;
2087     default:
2088       jj_la1[57] = jj_gen;
2089       jj_consume_token(-1);
2090       throw new ParseException();
2091     }
2092     jj_consume_token(RPAREN);
2093     expr = UnaryExpression();
2094    {if (true) return new CastExpression(type,expr,pos,SimpleCharStream.getPosition());}
2095     throw new Error("Missing return statement in function");
2096   }
2097
2098   static final public Expression PostfixExpression() throws ParseException {
2099   final Expression expr;
2100   int operator = -1;
2101   final int pos = SimpleCharStream.getPosition();
2102     expr = PrimaryExpression();
2103     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2104     case PLUS_PLUS:
2105     case MINUS_MINUS:
2106       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2107       case PLUS_PLUS:
2108         jj_consume_token(PLUS_PLUS);
2109                      operator = OperatorIds.PLUS_PLUS;
2110         break;
2111       case MINUS_MINUS:
2112         jj_consume_token(MINUS_MINUS);
2113                      operator = OperatorIds.MINUS_MINUS;
2114         break;
2115       default:
2116         jj_la1[58] = jj_gen;
2117         jj_consume_token(-1);
2118         throw new ParseException();
2119       }
2120       break;
2121     default:
2122       jj_la1[59] = jj_gen;
2123       ;
2124     }
2125     if (operator == -1) {
2126       {if (true) return expr;}
2127     }
2128     {if (true) return new PostfixedUnaryExpression(expr,operator,pos);}
2129     throw new Error("Missing return statement in function");
2130   }
2131
2132   static final public Expression PrimaryExpression() throws ParseException {
2133   Expression expr;
2134   int assignOperator = -1;
2135   final Token identifier;
2136   final String var;
2137   final int pos = SimpleCharStream.getPosition();
2138     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2139     case IDENTIFIER:
2140       identifier = jj_consume_token(IDENTIFIER);
2141    expr = new ConstantIdentifier(token.image.toCharArray(),
2142                                  pos,
2143                                  SimpleCharStream.getPosition());
2144       label_19:
2145       while (true) {
2146         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2147         case CLASSACCESS:
2148         case STATICCLASSACCESS:
2149         case LPAREN:
2150         case LBRACKET:
2151           ;
2152           break;
2153         default:
2154           jj_la1[60] = jj_gen;
2155           break label_19;
2156         }
2157         expr = PrimarySuffix(expr);
2158       }
2159    {if (true) return expr;}
2160       break;
2161     case ARRAY:
2162       expr = ArrayDeclarator();
2163    {if (true) return expr;}
2164       break;
2165     case NEW:
2166       jj_consume_token(NEW);
2167       expr = ClassIdentifier();
2168    expr = new PrefixedUnaryExpression(expr,OperatorIds.NEW,pos);
2169       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2170       case LPAREN:
2171         expr = Arguments(expr);
2172         break;
2173       default:
2174         jj_la1[61] = jj_gen;
2175         ;
2176       }
2177    {if (true) return expr;}
2178       break;
2179     default:
2180       jj_la1[62] = jj_gen;
2181       jj_consume_token(-1);
2182       throw new ParseException();
2183     }
2184     throw new Error("Missing return statement in function");
2185   }
2186
2187   static final public AbstractSuffixExpression PrimarySuffix(final Expression prefix) throws ParseException {
2188   final AbstractSuffixExpression suffix;
2189   final Expression expr;
2190     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2191     case LPAREN:
2192       suffix = Arguments(prefix);
2193                                    {if (true) return suffix;}
2194       break;
2195     case CLASSACCESS:
2196     case LBRACKET:
2197       suffix = VariableSuffix(prefix);
2198                                    {if (true) return suffix;}
2199       break;
2200     case STATICCLASSACCESS:
2201       jj_consume_token(STATICCLASSACCESS);
2202       expr = ClassIdentifier();
2203    suffix = new ClassAccess(prefix,
2204                             expr,
2205                             ClassAccess.STATIC);
2206    {if (true) return suffix;}
2207       break;
2208     default:
2209       jj_la1[63] = jj_gen;
2210       jj_consume_token(-1);
2211       throw new ParseException();
2212     }
2213     throw new Error("Missing return statement in function");
2214   }
2215
2216 /**
2217  * An array declarator.
2218  * array(vars)
2219  * @return an array
2220  */
2221   static final public ArrayInitializer ArrayDeclarator() throws ParseException {
2222   final ArrayVariableDeclaration[] vars;
2223   final int pos = SimpleCharStream.getPosition();
2224     jj_consume_token(ARRAY);
2225     vars = ArrayInitializer();
2226    {if (true) return new ArrayInitializer(vars,pos,SimpleCharStream.getPosition());}
2227     throw new Error("Missing return statement in function");
2228   }
2229
2230   static final public PrefixedUnaryExpression classInstantiation() throws ParseException {
2231   Expression expr;
2232   final StringBuffer buff;
2233   final int pos = SimpleCharStream.getPosition();
2234     jj_consume_token(NEW);
2235     expr = ClassIdentifier();
2236     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2237     case ARRAY:
2238     case NEW:
2239     case IDENTIFIER:
2240      buff = new StringBuffer(expr.toStringExpression());
2241       expr = PrimaryExpression();
2242      buff.append(expr.toStringExpression());
2243     expr = new ConstantIdentifier(buff.toString().toCharArray(),
2244                                   pos,
2245                                   SimpleCharStream.getPosition());
2246       break;
2247     default:
2248       jj_la1[64] = jj_gen;
2249       ;
2250     }
2251    {if (true) return new PrefixedUnaryExpression(expr,
2252                                       OperatorIds.NEW,
2253                                       pos);}
2254     throw new Error("Missing return statement in function");
2255   }
2256
2257   static final public ConstantIdentifier ClassIdentifier() throws ParseException {
2258   final String expr;
2259   final Token token;
2260   final int pos = SimpleCharStream.getPosition();
2261   final ConstantIdentifier type;
2262     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2263     case IDENTIFIER:
2264       token = jj_consume_token(IDENTIFIER);
2265                                  {if (true) return new ConstantIdentifier(token.image.toCharArray(),
2266                                                                pos,
2267                                                                SimpleCharStream.getPosition());}
2268       break;
2269     case STRING:
2270     case OBJECT:
2271     case BOOL:
2272     case BOOLEAN:
2273     case REAL:
2274     case DOUBLE:
2275     case FLOAT:
2276     case INT:
2277     case INTEGER:
2278       type = Type();
2279                           {if (true) return type;}
2280       break;
2281     case DOLLAR:
2282     case DOLLAR_ID:
2283       expr = VariableDeclaratorId();
2284                                  {if (true) return new ConstantIdentifier(expr.toCharArray(),
2285                                                                pos,
2286                                                                SimpleCharStream.getPosition());}
2287       break;
2288     default:
2289       jj_la1[65] = jj_gen;
2290       jj_consume_token(-1);
2291       throw new ParseException();
2292     }
2293     throw new Error("Missing return statement in function");
2294   }
2295
2296   static final public AbstractSuffixExpression VariableSuffix(final Expression prefix) throws ParseException {
2297   String expr = null;
2298   final int pos = SimpleCharStream.getPosition();
2299   Expression expression = null;
2300     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2301     case CLASSACCESS:
2302       jj_consume_token(CLASSACCESS);
2303       try {
2304         expr = VariableName();
2305       } catch (ParseException e) {
2306     errorMessage = "unexpected token : '"+ e.currentToken.next.image +"', function call or field access expected";
2307     errorLevel   = ERROR;
2308     errorStart = SimpleCharStream.getPosition() - e.currentToken.next.image.length() + 1;
2309     errorEnd   = SimpleCharStream.getPosition() + 1;
2310     {if (true) throw e;}
2311       }
2312    {if (true) return new ClassAccess(prefix,
2313                           new ConstantIdentifier(expr.toCharArray(),pos,SimpleCharStream.getPosition()),
2314                           ClassAccess.NORMAL);}
2315       break;
2316     case LBRACKET:
2317       jj_consume_token(LBRACKET);
2318       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2319       case ARRAY:
2320       case LIST:
2321       case PRINT:
2322       case NEW:
2323       case NULL:
2324       case TRUE:
2325       case FALSE:
2326       case STRING:
2327       case OBJECT:
2328       case BOOL:
2329       case BOOLEAN:
2330       case REAL:
2331       case DOUBLE:
2332       case FLOAT:
2333       case INT:
2334       case INTEGER:
2335       case AT:
2336       case DOLLAR:
2337       case BANG:
2338       case PLUS_PLUS:
2339       case MINUS_MINUS:
2340       case PLUS:
2341       case MINUS:
2342       case BIT_AND:
2343       case INTEGER_LITERAL:
2344       case FLOATING_POINT_LITERAL:
2345       case STRING_LITERAL:
2346       case IDENTIFIER:
2347       case LPAREN:
2348       case DOLLAR_ID:
2349         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2350         case ARRAY:
2351         case LIST:
2352         case PRINT:
2353         case NEW:
2354         case NULL:
2355         case TRUE:
2356         case FALSE:
2357         case AT:
2358         case DOLLAR:
2359         case BANG:
2360         case PLUS_PLUS:
2361         case MINUS_MINUS:
2362         case PLUS:
2363         case MINUS:
2364         case BIT_AND:
2365         case INTEGER_LITERAL:
2366         case FLOATING_POINT_LITERAL:
2367         case STRING_LITERAL:
2368         case IDENTIFIER:
2369         case LPAREN:
2370         case DOLLAR_ID:
2371           expression = Expression();
2372           break;
2373         case STRING:
2374         case OBJECT:
2375         case BOOL:
2376         case BOOLEAN:
2377         case REAL:
2378         case DOUBLE:
2379         case FLOAT:
2380         case INT:
2381         case INTEGER:
2382           expression = Type();
2383           break;
2384         default:
2385           jj_la1[66] = jj_gen;
2386           jj_consume_token(-1);
2387           throw new ParseException();
2388         }
2389         break;
2390       default:
2391         jj_la1[67] = jj_gen;
2392         ;
2393       }
2394       try {
2395         jj_consume_token(RBRACKET);
2396       } catch (ParseException e) {
2397     errorMessage = "']' expected";
2398     errorLevel   = ERROR;
2399     errorStart = SimpleCharStream.getPosition() - e.currentToken.next.image.length() + 1;
2400     errorEnd   = SimpleCharStream.getPosition() + 1;
2401     {if (true) throw e;}
2402       }
2403    {if (true) return new ArrayDeclarator(prefix,expression,SimpleCharStream.getPosition());}
2404       break;
2405     default:
2406       jj_la1[68] = jj_gen;
2407       jj_consume_token(-1);
2408       throw new ParseException();
2409     }
2410     throw new Error("Missing return statement in function");
2411   }
2412
2413   static final public Literal Literal() throws ParseException {
2414   final Token token;
2415   final int pos;
2416     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2417     case INTEGER_LITERAL:
2418       token = jj_consume_token(INTEGER_LITERAL);
2419                                     pos = SimpleCharStream.getPosition();
2420                                     {if (true) return new NumberLiteral(token.image.toCharArray(),pos-token.image.length(),pos);}
2421       break;
2422     case FLOATING_POINT_LITERAL:
2423       token = jj_consume_token(FLOATING_POINT_LITERAL);
2424                                     pos = SimpleCharStream.getPosition();
2425                                     {if (true) return new NumberLiteral(token.image.toCharArray(),pos-token.image.length(),pos);}
2426       break;
2427     case STRING_LITERAL:
2428       token = jj_consume_token(STRING_LITERAL);
2429                                     pos = SimpleCharStream.getPosition();
2430                                     {if (true) return new StringLiteral(token.image.toCharArray(),pos-token.image.length());}
2431       break;
2432     case TRUE:
2433       jj_consume_token(TRUE);
2434                                     pos = SimpleCharStream.getPosition();
2435                                     {if (true) return new TrueLiteral(pos-4,pos);}
2436       break;
2437     case FALSE:
2438       jj_consume_token(FALSE);
2439                                     pos = SimpleCharStream.getPosition();
2440                                     {if (true) return new FalseLiteral(pos-4,pos);}
2441       break;
2442     case NULL:
2443       jj_consume_token(NULL);
2444                                     pos = SimpleCharStream.getPosition();
2445                                     {if (true) return new NullLiteral(pos-4,pos);}
2446       break;
2447     default:
2448       jj_la1[69] = jj_gen;
2449       jj_consume_token(-1);
2450       throw new ParseException();
2451     }
2452     throw new Error("Missing return statement in function");
2453   }
2454
2455   static final public FunctionCall Arguments(final Expression func) throws ParseException {
2456 Expression[] args = null;
2457     jj_consume_token(LPAREN);
2458     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2459     case ARRAY:
2460     case LIST:
2461     case PRINT:
2462     case NEW:
2463     case NULL:
2464     case TRUE:
2465     case FALSE:
2466     case AT:
2467     case DOLLAR:
2468     case BANG:
2469     case PLUS_PLUS:
2470     case MINUS_MINUS:
2471     case PLUS:
2472     case MINUS:
2473     case BIT_AND:
2474     case INTEGER_LITERAL:
2475     case FLOATING_POINT_LITERAL:
2476     case STRING_LITERAL:
2477     case IDENTIFIER:
2478     case LPAREN:
2479     case DOLLAR_ID:
2480       args = ArgumentList();
2481       break;
2482     default:
2483       jj_la1[70] = jj_gen;
2484       ;
2485     }
2486     try {
2487       jj_consume_token(RPAREN);
2488     } catch (ParseException e) {
2489     errorMessage = "unexpected token : '"+ e.currentToken.next.image +"', ')' expected to close the argument list";
2490     errorLevel   = ERROR;
2491     errorStart = SimpleCharStream.getPosition() - e.currentToken.next.image.length() + 1;
2492     errorEnd   = SimpleCharStream.getPosition() + 1;
2493     {if (true) throw e;}
2494     }
2495    {if (true) return new FunctionCall(func,args,SimpleCharStream.getPosition());}
2496     throw new Error("Missing return statement in function");
2497   }
2498
2499 /**
2500  * An argument list is a list of arguments separated by comma :
2501  * argumentDeclaration() (, argumentDeclaration)*
2502  * @return an array of arguments
2503  */
2504   static final public Expression[] ArgumentList() throws ParseException {
2505 Expression arg;
2506 final ArrayList list = new ArrayList();
2507     arg = Expression();
2508    list.add(arg);
2509     label_20:
2510     while (true) {
2511       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2512       case COMMA:
2513         ;
2514         break;
2515       default:
2516         jj_la1[71] = jj_gen;
2517         break label_20;
2518       }
2519       jj_consume_token(COMMA);
2520       try {
2521         arg = Expression();
2522          list.add(arg);
2523       } catch (ParseException e) {
2524         errorMessage = "unexpected token : '"+ e.currentToken.next.image +"'. An expression expected after a comma in argument list";
2525         errorLevel   = ERROR;
2526         errorStart   = SimpleCharStream.getPosition() - e.currentToken.next.image.length() + 1;
2527         errorEnd     = SimpleCharStream.getPosition() + 1;
2528         {if (true) throw e;}
2529       }
2530     }
2531    final Expression[] arguments = new Expression[list.size()];
2532    list.toArray(arguments);
2533    {if (true) return arguments;}
2534     throw new Error("Missing return statement in function");
2535   }
2536
2537 /**
2538  * A Statement without break.
2539  */
2540   static final public Statement StatementNoBreak() throws ParseException {
2541   final Statement statement;
2542   Token token = null;
2543     if (jj_2_4(2)) {
2544       statement = Expression();
2545       try {
2546         jj_consume_token(SEMICOLON);
2547       } catch (ParseException e) {
2548     if (e.currentToken.next.kind != PHPParserConstants.PHPEND) {
2549       errorMessage = "unexpected token : '"+ e.currentToken.next.image +"'. A ';' was expected";
2550       errorLevel   = ERROR;
2551       errorStart = SimpleCharStream.getPosition() - e.currentToken.next.image.length() + 1;
2552       errorEnd   = SimpleCharStream.getPosition() + 1;
2553       {if (true) throw e;}
2554     }
2555       }
2556    {if (true) return statement;}
2557     } else {
2558       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2559       case IDENTIFIER:
2560         statement = LabeledStatement();
2561                                   {if (true) return statement;}
2562         break;
2563       case LBRACE:
2564         statement = Block();
2565                                   {if (true) return statement;}
2566         break;
2567       case SEMICOLON:
2568         statement = EmptyStatement();
2569                                   {if (true) return statement;}
2570         break;
2571       case SWITCH:
2572         statement = SwitchStatement();
2573                                          {if (true) return statement;}
2574         break;
2575       case IF:
2576         statement = IfStatement();
2577                                          {if (true) return statement;}
2578         break;
2579       case WHILE:
2580         statement = WhileStatement();
2581                                          {if (true) return statement;}
2582         break;
2583       case DO:
2584         statement = DoStatement();
2585                                          {if (true) return statement;}
2586         break;
2587       case FOR:
2588         statement = ForStatement();
2589                                          {if (true) return statement;}
2590         break;
2591       case FOREACH:
2592         statement = ForeachStatement();
2593                                          {if (true) return statement;}
2594         break;
2595       case CONTINUE:
2596         statement = ContinueStatement();
2597                                          {if (true) return statement;}
2598         break;
2599       case RETURN:
2600         statement = ReturnStatement();
2601                                          {if (true) return statement;}
2602         break;
2603       case ECHO:
2604         statement = EchoStatement();
2605                                          {if (true) return statement;}
2606         break;
2607       case INCLUDE:
2608       case REQUIRE:
2609       case INCLUDE_ONCE:
2610       case REQUIRE_ONCE:
2611       case AT:
2612         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2613         case AT:
2614           token = jj_consume_token(AT);
2615           break;
2616         default:
2617           jj_la1[72] = jj_gen;
2618           ;
2619         }
2620         statement = IncludeStatement();
2621    if (token != null) {
2622     ((InclusionStatement)statement).silent = true;
2623   }
2624   {if (true) return statement;}
2625         break;
2626       case STATIC:
2627         statement = StaticStatement();
2628                                          {if (true) return statement;}
2629         break;
2630       case GLOBAL:
2631         statement = GlobalStatement();
2632                                          {if (true) return statement;}
2633         break;
2634       case DEFINE:
2635         statement = defineStatement();
2636                                          currentSegment.add((Outlineable)statement);{if (true) return statement;}
2637         break;
2638       default:
2639         jj_la1[73] = jj_gen;
2640         jj_consume_token(-1);
2641         throw new ParseException();
2642       }
2643     }
2644     throw new Error("Missing return statement in function");
2645   }
2646
2647   static final public Define defineStatement() throws ParseException {
2648   final int start = SimpleCharStream.getPosition();
2649   Expression defineName,defineValue;
2650     jj_consume_token(DEFINE);
2651     try {
2652       jj_consume_token(LPAREN);
2653     } catch (ParseException e) {
2654     errorMessage = "unexpected token : '"+ e.currentToken.next.image +"', '(' expected";
2655     errorLevel   = ERROR;
2656     errorStart   = SimpleCharStream.getPosition() - e.currentToken.next.image.length() + 1;
2657     errorEnd     = SimpleCharStream.getPosition() + 1;
2658     processParseException(e);
2659     }
2660     try {
2661       defineName = Expression();
2662     } catch (ParseException e) {
2663     errorMessage = "unexpected token : '"+ e.currentToken.next.image +"', expression expected";
2664     errorLevel   = ERROR;
2665     errorStart   = SimpleCharStream.getPosition() - e.currentToken.next.image.length() + 1;
2666     errorEnd     = SimpleCharStream.getPosition() + 1;
2667     {if (true) throw e;}
2668     }
2669     try {
2670       jj_consume_token(COMMA);
2671     } catch (ParseException e) {
2672     errorMessage = "unexpected token : '"+ e.currentToken.next.image +"', ',' expected";
2673     errorLevel   = ERROR;
2674     errorStart   = SimpleCharStream.getPosition() - e.currentToken.next.image.length() + 1;
2675     errorEnd     = SimpleCharStream.getPosition() + 1;
2676     processParseException(e);
2677     }
2678     try {
2679       defineValue = Expression();
2680     } catch (ParseException e) {
2681     errorMessage = "unexpected token : '"+ e.currentToken.next.image +"', expression expected";
2682     errorLevel   = ERROR;
2683     errorStart   = SimpleCharStream.getPosition() - e.currentToken.next.image.length() + 1;
2684     errorEnd     = SimpleCharStream.getPosition() + 1;
2685     {if (true) throw e;}
2686     }
2687     try {
2688       jj_consume_token(RPAREN);
2689     } catch (ParseException e) {
2690     errorMessage = "unexpected token : '"+ e.currentToken.next.image +"', ')' expected";
2691     errorLevel   = ERROR;
2692     errorStart   = SimpleCharStream.getPosition() - e.currentToken.next.image.length() + 1;
2693     errorEnd     = SimpleCharStream.getPosition() + 1;
2694     processParseException(e);
2695     }
2696    {if (true) return new Define(currentSegment,
2697                      defineName,
2698                      defineValue,
2699                      start,
2700                      SimpleCharStream.getPosition());}
2701     throw new Error("Missing return statement in function");
2702   }
2703
2704 /**
2705  * A Normal statement.
2706  */
2707   static final public Statement Statement() throws ParseException {
2708   final Statement statement;
2709     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2710     case IF:
2711     case ARRAY:
2712     case LIST:
2713     case PRINT:
2714     case ECHO:
2715     case INCLUDE:
2716     case REQUIRE:
2717     case INCLUDE_ONCE:
2718     case REQUIRE_ONCE:
2719     case GLOBAL:
2720     case DEFINE:
2721     case STATIC:
2722     case CONTINUE:
2723     case DO:
2724     case FOR:
2725     case NEW:
2726     case NULL:
2727     case RETURN:
2728     case SWITCH:
2729     case TRUE:
2730     case FALSE:
2731     case WHILE:
2732     case FOREACH:
2733     case AT:
2734     case DOLLAR:
2735     case BANG:
2736     case PLUS_PLUS:
2737     case MINUS_MINUS:
2738     case PLUS:
2739     case MINUS:
2740     case BIT_AND:
2741     case INTEGER_LITERAL:
2742     case FLOATING_POINT_LITERAL:
2743     case STRING_LITERAL:
2744     case IDENTIFIER:
2745     case LPAREN:
2746     case LBRACE:
2747     case SEMICOLON:
2748     case DOLLAR_ID:
2749       statement = StatementNoBreak();
2750                                   {if (true) return statement;}
2751       break;
2752     case BREAK:
2753       statement = BreakStatement();
2754                                   {if (true) return statement;}
2755       break;
2756     default:
2757       jj_la1[74] = jj_gen;
2758       jj_consume_token(-1);
2759       throw new ParseException();
2760     }
2761     throw new Error("Missing return statement in function");
2762   }
2763
2764 /**
2765  * An html block inside a php syntax.
2766  */
2767   static final public HTMLBlock htmlBlock() throws ParseException {
2768   final int startIndex = nodePtr;
2769   final AstNode[] blockNodes;
2770   final int nbNodes;
2771     jj_consume_token(PHPEND);
2772     label_21:
2773     while (true) {
2774       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2775       case PHPECHOSTART:
2776         ;
2777         break;
2778       default:
2779         jj_la1[75] = jj_gen;
2780         break label_21;
2781       }
2782       phpEchoBlock();
2783     }
2784     try {
2785       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2786       case PHPSTARTLONG:
2787         jj_consume_token(PHPSTARTLONG);
2788         break;
2789       case PHPSTARTSHORT:
2790         jj_consume_token(PHPSTARTSHORT);
2791         break;
2792       default:
2793         jj_la1[76] = jj_gen;
2794         jj_consume_token(-1);
2795         throw new ParseException();
2796       }
2797     } catch (ParseException e) {
2798     errorMessage = "unexpected end of file , '<?php' expected";
2799     errorLevel   = ERROR;
2800     errorStart   = SimpleCharStream.getPosition();
2801     errorEnd     = SimpleCharStream.getPosition();
2802     {if (true) throw e;}
2803     }
2804   nbNodes    = nodePtr - startIndex;
2805   blockNodes = new AstNode[nbNodes];
2806   System.arraycopy(nodes,startIndex,blockNodes,0,nbNodes);
2807   nodePtr = startIndex;
2808   {if (true) return new HTMLBlock(blockNodes);}
2809     throw new Error("Missing return statement in function");
2810   }
2811
2812 /**
2813  * An include statement. It's "include" an expression;
2814  */
2815   static final public InclusionStatement IncludeStatement() throws ParseException {
2816   final Expression expr;
2817   final int keyword;
2818   final int pos = SimpleCharStream.getPosition();
2819   final InclusionStatement inclusionStatement;
2820     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2821     case REQUIRE:
2822       jj_consume_token(REQUIRE);
2823                          keyword = InclusionStatement.REQUIRE;
2824       break;
2825     case REQUIRE_ONCE:
2826       jj_consume_token(REQUIRE_ONCE);
2827                          keyword = InclusionStatement.REQUIRE_ONCE;
2828       break;
2829     case INCLUDE:
2830       jj_consume_token(INCLUDE);
2831                          keyword = InclusionStatement.INCLUDE;
2832       break;
2833     case INCLUDE_ONCE:
2834       jj_consume_token(INCLUDE_ONCE);
2835                          keyword = InclusionStatement.INCLUDE_ONCE;
2836       break;
2837     default:
2838       jj_la1[77] = jj_gen;
2839       jj_consume_token(-1);
2840       throw new ParseException();
2841     }
2842     try {
2843       expr = Expression();
2844     } catch (ParseException e) {
2845     if (errorMessage != null) {
2846       {if (true) throw e;}
2847     }
2848     errorMessage = "unexpected token '"+ e.currentToken.next.image+"', expression expected";
2849     errorLevel   = ERROR;
2850     errorStart   = SimpleCharStream.getPosition() - e.currentToken.next.image.length() + 1;
2851     errorEnd     = SimpleCharStream.getPosition() + 1;
2852     {if (true) throw e;}
2853     }
2854    inclusionStatement = new InclusionStatement(currentSegment,
2855                                                keyword,
2856                                                expr,
2857                                                pos);
2858    currentSegment.add(inclusionStatement);
2859     try {
2860       jj_consume_token(SEMICOLON);
2861     } catch (ParseException e) {
2862     errorMessage = "unexpected token : '"+ e.currentToken.next.image +"'. A ';' was expected";
2863     errorLevel   = ERROR;
2864     errorStart   = SimpleCharStream.getPosition() - e.currentToken.next.image.length() + 1;
2865     errorEnd     = SimpleCharStream.getPosition() + 1;
2866     {if (true) throw e;}
2867     }
2868    {if (true) return inclusionStatement;}
2869     throw new Error("Missing return statement in function");
2870   }
2871
2872   static final public PrintExpression PrintExpression() throws ParseException {
2873   final Expression expr;
2874   final int pos = SimpleCharStream.getPosition();
2875     jj_consume_token(PRINT);
2876     expr = Expression();
2877                                {if (true) return new PrintExpression(expr,pos,SimpleCharStream.getPosition());}
2878     throw new Error("Missing return statement in function");
2879   }
2880
2881   static final public ListExpression ListExpression() throws ParseException {
2882   String expr = null;
2883   final Expression expression;
2884   final ArrayList list = new ArrayList();
2885   final int pos = SimpleCharStream.getPosition();
2886     jj_consume_token(LIST);
2887     try {
2888       jj_consume_token(LPAREN);
2889     } catch (ParseException e) {
2890     errorMessage = "unexpected token : '"+ e.currentToken.next.image +"', '(' expected";
2891     errorLevel   = ERROR;
2892     errorStart   = SimpleCharStream.getPosition() - e.currentToken.next.image.length() + 1;
2893     errorEnd     = SimpleCharStream.getPosition() + 1;
2894     {if (true) throw e;}
2895     }
2896     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2897     case DOLLAR:
2898     case DOLLAR_ID:
2899       expr = VariableDeclaratorId();
2900      list.add(expr);
2901       break;
2902     default:
2903       jj_la1[78] = jj_gen;
2904       ;
2905     }
2906    if (expr == null) list.add(null);
2907     label_22:
2908     while (true) {
2909       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2910       case COMMA:
2911         ;
2912         break;
2913       default:
2914         jj_la1[79] = jj_gen;
2915         break label_22;
2916       }
2917       try {
2918         jj_consume_token(COMMA);
2919       } catch (ParseException e) {
2920       errorMessage = "unexpected token : '"+ e.currentToken.next.image +"', ',' expected";
2921       errorLevel   = ERROR;
2922       errorStart   = SimpleCharStream.getPosition() - e.currentToken.next.image.length() + 1;
2923       errorEnd     = SimpleCharStream.getPosition() + 1;
2924       {if (true) throw e;}
2925       }
2926       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2927       case DOLLAR:
2928       case DOLLAR_ID:
2929         expr = VariableDeclaratorId();
2930                                     list.add(expr);
2931         break;
2932       default:
2933         jj_la1[80] = jj_gen;
2934         ;
2935       }
2936     }
2937     try {
2938       jj_consume_token(RPAREN);
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 ASSIGN:
2948       jj_consume_token(ASSIGN);
2949       expression = Expression();
2950     final String[] strings = new String[list.size()];
2951     list.toArray(strings);
2952     {if (true) return new ListExpression(strings,
2953                               expression,
2954                               pos,
2955                               SimpleCharStream.getPosition());}
2956       break;
2957     default:
2958       jj_la1[81] = jj_gen;
2959       ;
2960     }
2961     final String[] strings = new String[list.size()];
2962     list.toArray(strings);
2963     {if (true) return new ListExpression(strings,pos,SimpleCharStream.getPosition());}
2964     throw new Error("Missing return statement in function");
2965   }
2966
2967 /**
2968  * An echo statement.
2969  * echo anyexpression (, otherexpression)*
2970  */
2971   static final public EchoStatement EchoStatement() throws ParseException {
2972   final ArrayList expressions = new ArrayList();
2973   Expression expr;
2974   final int pos = SimpleCharStream.getPosition();
2975     jj_consume_token(ECHO);
2976     expr = Expression();
2977    expressions.add(expr);
2978     label_23:
2979     while (true) {
2980       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2981       case COMMA:
2982         ;
2983         break;
2984       default:
2985         jj_la1[82] = jj_gen;
2986         break label_23;
2987       }
2988       jj_consume_token(COMMA);
2989       expr = Expression();
2990      expressions.add(expr);
2991     }
2992     try {
2993       jj_consume_token(SEMICOLON);
2994     } catch (ParseException e) {
2995     if (e.currentToken.next.kind != 4) {
2996       errorMessage = "';' expected after 'echo' statement";
2997       errorLevel   = ERROR;
2998       errorStart   = SimpleCharStream.getPosition() - e.currentToken.next.image.length() + 1;
2999       errorEnd     = SimpleCharStream.getPosition() + 1;
3000       {if (true) throw e;}
3001     }
3002     }
3003    final Expression[] exprs = new Expression[expressions.size()];
3004    expressions.toArray(exprs);
3005    {if (true) return new EchoStatement(exprs,pos);}
3006     throw new Error("Missing return statement in function");
3007   }
3008
3009   static final public GlobalStatement GlobalStatement() throws ParseException {
3010    final int pos = SimpleCharStream.getPosition();
3011    String expr;
3012    final ArrayList vars = new ArrayList();
3013    final GlobalStatement global;
3014     jj_consume_token(GLOBAL);
3015     expr = VariableDeclaratorId();
3016      vars.add(expr);
3017     label_24:
3018     while (true) {
3019       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3020       case COMMA:
3021         ;
3022         break;
3023       default:
3024         jj_la1[83] = jj_gen;
3025         break label_24;
3026       }
3027       jj_consume_token(COMMA);
3028       expr = VariableDeclaratorId();
3029      vars.add(expr);
3030     }
3031     try {
3032       jj_consume_token(SEMICOLON);
3033     final String[] strings = new String[vars.size()];
3034     vars.toArray(strings);
3035     global = new GlobalStatement(currentSegment,
3036                                  strings,
3037                                  pos,
3038                                  SimpleCharStream.getPosition());
3039     currentSegment.add(global);
3040     {if (true) return global;}
3041     } catch (ParseException e) {
3042     errorMessage = "unexpected token : '"+ e.currentToken.next.image +"'. a ';' was expected";
3043     errorLevel   = ERROR;
3044     errorStart = SimpleCharStream.getPosition() - e.currentToken.next.image.length() + 1;
3045     errorEnd   = SimpleCharStream.getPosition() + 1;
3046     {if (true) throw e;}
3047     }
3048     throw new Error("Missing return statement in function");
3049   }
3050
3051   static final public StaticStatement StaticStatement() throws ParseException {
3052   final int pos = SimpleCharStream.getPosition();
3053   final ArrayList vars = new ArrayList();
3054   VariableDeclaration expr;
3055     jj_consume_token(STATIC);
3056     expr = VariableDeclarator();
3057                                         vars.add(new String(expr.name));
3058     label_25:
3059     while (true) {
3060       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3061       case COMMA:
3062         ;
3063         break;
3064       default:
3065         jj_la1[84] = jj_gen;
3066         break label_25;
3067       }
3068       jj_consume_token(COMMA);
3069       expr = VariableDeclarator();
3070                                         vars.add(new String(expr.name));
3071     }
3072     try {
3073       jj_consume_token(SEMICOLON);
3074     final String[] strings = new String[vars.size()];
3075     vars.toArray(strings);
3076     {if (true) return new StaticStatement(strings,
3077                                 pos,
3078                                 SimpleCharStream.getPosition());}
3079     } catch (ParseException e) {
3080     errorMessage = "unexpected token : '"+ e.currentToken.next.image +"'. a ';' was expected";
3081     errorLevel   = ERROR;
3082     errorStart = SimpleCharStream.getPosition() - e.currentToken.next.image.length() + 1;
3083     errorEnd   = SimpleCharStream.getPosition() + 1;
3084     {if (true) throw e;}
3085     }
3086     throw new Error("Missing return statement in function");
3087   }
3088
3089   static final public LabeledStatement LabeledStatement() throws ParseException {
3090   final int pos = SimpleCharStream.getPosition();
3091   final Token label;
3092   final Statement statement;
3093     label = jj_consume_token(IDENTIFIER);
3094     jj_consume_token(COLON);
3095     statement = Statement();
3096    {if (true) return new LabeledStatement(label.image.toCharArray(),statement,pos,SimpleCharStream.getPosition());}
3097     throw new Error("Missing return statement in function");
3098   }
3099
3100 /**
3101  * A Block is
3102  * {
3103  * statements
3104  * }.
3105  * @return a block
3106  */
3107   static final public Block Block() throws ParseException {
3108   final int pos = SimpleCharStream.getPosition();
3109   final ArrayList list = new ArrayList();
3110   Statement statement;
3111     try {
3112       jj_consume_token(LBRACE);
3113     } catch (ParseException e) {
3114     errorMessage = "'{' expected";
3115     errorLevel   = ERROR;
3116     errorStart = SimpleCharStream.getPosition() - e.currentToken.next.image.length() + 1;
3117     errorEnd   = SimpleCharStream.getPosition() + 1;
3118     {if (true) throw e;}
3119     }
3120     label_26:
3121     while (true) {
3122       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3123       case PHPEND:
3124       case CLASS:
3125       case FUNCTION:
3126       case IF:
3127       case ARRAY:
3128       case BREAK:
3129       case LIST:
3130       case PRINT:
3131       case ECHO:
3132       case INCLUDE:
3133       case REQUIRE:
3134       case INCLUDE_ONCE:
3135       case REQUIRE_ONCE:
3136       case GLOBAL:
3137       case DEFINE:
3138       case STATIC:
3139       case CONTINUE:
3140       case DO:
3141       case FOR:
3142       case NEW:
3143       case NULL:
3144       case RETURN:
3145       case SWITCH:
3146       case TRUE:
3147       case FALSE:
3148       case WHILE:
3149       case FOREACH:
3150       case AT:
3151       case DOLLAR:
3152       case BANG:
3153       case PLUS_PLUS:
3154       case MINUS_MINUS:
3155       case PLUS:
3156       case MINUS:
3157       case BIT_AND:
3158       case INTEGER_LITERAL:
3159       case FLOATING_POINT_LITERAL:
3160       case STRING_LITERAL:
3161       case IDENTIFIER:
3162       case LPAREN:
3163       case LBRACE:
3164       case SEMICOLON:
3165       case DOLLAR_ID:
3166         ;
3167         break;
3168       default:
3169         jj_la1[85] = jj_gen;
3170         break label_26;
3171       }
3172       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3173       case CLASS:
3174       case FUNCTION:
3175       case IF:
3176       case ARRAY:
3177       case BREAK:
3178       case LIST:
3179       case PRINT:
3180       case ECHO:
3181       case INCLUDE:
3182       case REQUIRE:
3183       case INCLUDE_ONCE:
3184       case REQUIRE_ONCE:
3185       case GLOBAL:
3186       case DEFINE:
3187       case STATIC:
3188       case CONTINUE:
3189       case DO:
3190       case FOR:
3191       case NEW:
3192       case NULL:
3193       case RETURN:
3194       case SWITCH:
3195       case TRUE:
3196       case FALSE:
3197       case WHILE:
3198       case FOREACH:
3199       case AT:
3200       case DOLLAR:
3201       case BANG:
3202       case PLUS_PLUS:
3203       case MINUS_MINUS:
3204       case PLUS:
3205       case MINUS:
3206       case BIT_AND:
3207       case INTEGER_LITERAL:
3208       case FLOATING_POINT_LITERAL:
3209       case STRING_LITERAL:
3210       case IDENTIFIER:
3211       case LPAREN:
3212       case LBRACE:
3213       case SEMICOLON:
3214       case DOLLAR_ID:
3215         statement = BlockStatement();
3216                                   list.add(statement);
3217         break;
3218       case PHPEND:
3219         statement = htmlBlock();
3220                                   list.add(statement);
3221         break;
3222       default:
3223         jj_la1[86] = jj_gen;
3224         jj_consume_token(-1);
3225         throw new ParseException();
3226       }
3227     }
3228     try {
3229       jj_consume_token(RBRACE);
3230     } catch (ParseException e) {
3231     errorMessage = "unexpected token : '"+ e.currentToken.image +"', '}' expected";
3232     errorLevel   = ERROR;
3233     errorStart = SimpleCharStream.getPosition() - e.currentToken.next.image.length() + 1;
3234     errorEnd   = SimpleCharStream.getPosition() + 1;
3235     {if (true) throw e;}
3236     }
3237   final Statement[] statements = new Statement[list.size()];
3238   list.toArray(statements);
3239   {if (true) return new Block(statements,pos,SimpleCharStream.getPosition());}
3240     throw new Error("Missing return statement in function");
3241   }
3242
3243   static final public Statement BlockStatement() throws ParseException {
3244   final Statement statement;
3245     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3246     case IF:
3247     case ARRAY:
3248     case BREAK:
3249     case LIST:
3250     case PRINT:
3251     case ECHO:
3252     case INCLUDE:
3253     case REQUIRE:
3254     case INCLUDE_ONCE:
3255     case REQUIRE_ONCE:
3256     case GLOBAL:
3257     case DEFINE:
3258     case STATIC:
3259     case CONTINUE:
3260     case DO:
3261     case FOR:
3262     case NEW:
3263     case NULL:
3264     case RETURN:
3265     case SWITCH:
3266     case TRUE:
3267     case FALSE:
3268     case WHILE:
3269     case FOREACH:
3270     case AT:
3271     case DOLLAR:
3272     case BANG:
3273     case PLUS_PLUS:
3274     case MINUS_MINUS:
3275     case PLUS:
3276     case MINUS:
3277     case BIT_AND:
3278     case INTEGER_LITERAL:
3279     case FLOATING_POINT_LITERAL:
3280     case STRING_LITERAL:
3281     case IDENTIFIER:
3282     case LPAREN:
3283     case LBRACE:
3284     case SEMICOLON:
3285     case DOLLAR_ID:
3286       statement = Statement();
3287                                    if (phpDocument == currentSegment) pushOnAstNodes(statement);
3288                                    {if (true) return statement;}
3289       break;
3290     case CLASS:
3291       statement = ClassDeclaration();
3292                                    {if (true) return statement;}
3293       break;
3294     case FUNCTION:
3295       statement = MethodDeclaration();
3296                                    if (phpDocument == currentSegment) pushOnAstNodes(statement);
3297                                    currentSegment.add((MethodDeclaration) statement);
3298                                    ((MethodDeclaration) statement).analyzeCode();
3299                                    {if (true) return statement;}
3300       break;
3301     default:
3302       jj_la1[87] = jj_gen;
3303       jj_consume_token(-1);
3304       throw new ParseException();
3305     }
3306     throw new Error("Missing return statement in function");
3307   }
3308
3309 /**
3310  * A Block statement that will not contain any 'break'
3311  */
3312   static final public Statement BlockStatementNoBreak() throws ParseException {
3313   final Statement statement;
3314     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3315     case IF:
3316     case ARRAY:
3317     case LIST:
3318     case PRINT:
3319     case ECHO:
3320     case INCLUDE:
3321     case REQUIRE:
3322     case INCLUDE_ONCE:
3323     case REQUIRE_ONCE:
3324     case GLOBAL:
3325     case DEFINE:
3326     case STATIC:
3327     case CONTINUE:
3328     case DO:
3329     case FOR:
3330     case NEW:
3331     case NULL:
3332     case RETURN:
3333     case SWITCH:
3334     case TRUE:
3335     case FALSE:
3336     case WHILE:
3337     case FOREACH:
3338     case AT:
3339     case DOLLAR:
3340     case BANG:
3341     case PLUS_PLUS:
3342     case MINUS_MINUS:
3343     case PLUS:
3344     case MINUS:
3345     case BIT_AND:
3346     case INTEGER_LITERAL:
3347     case FLOATING_POINT_LITERAL:
3348     case STRING_LITERAL:
3349     case IDENTIFIER:
3350     case LPAREN:
3351     case LBRACE:
3352     case SEMICOLON:
3353     case DOLLAR_ID:
3354       statement = StatementNoBreak();
3355                                    {if (true) return statement;}
3356       break;
3357     case CLASS:
3358       statement = ClassDeclaration();
3359                                    {if (true) return statement;}
3360       break;
3361     case FUNCTION:
3362       statement = MethodDeclaration();
3363                                    currentSegment.add((MethodDeclaration) statement);
3364                                    ((MethodDeclaration) statement).analyzeCode();
3365                                    {if (true) return statement;}
3366       break;
3367     default:
3368       jj_la1[88] = jj_gen;
3369       jj_consume_token(-1);
3370       throw new ParseException();
3371     }
3372     throw new Error("Missing return statement in function");
3373   }
3374
3375   static final public VariableDeclaration[] LocalVariableDeclaration() throws ParseException {
3376   final ArrayList list = new ArrayList();
3377   VariableDeclaration var;
3378     var = LocalVariableDeclarator();
3379    list.add(var);
3380     label_27:
3381     while (true) {
3382       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3383       case COMMA:
3384         ;
3385         break;
3386       default:
3387         jj_la1[89] = jj_gen;
3388         break label_27;
3389       }
3390       jj_consume_token(COMMA);
3391       var = LocalVariableDeclarator();
3392                                              list.add(var);
3393     }
3394     final VariableDeclaration[] vars = new VariableDeclaration[list.size()];
3395     list.toArray(vars);
3396   {if (true) return vars;}
3397     throw new Error("Missing return statement in function");
3398   }
3399
3400   static final public VariableDeclaration LocalVariableDeclarator() throws ParseException {
3401   final String varName;
3402   Expression initializer = null;
3403   final int pos = SimpleCharStream.getPosition();
3404     varName = VariableDeclaratorId();
3405     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3406     case ASSIGN:
3407       jj_consume_token(ASSIGN);
3408       initializer = Expression();
3409       break;
3410     default:
3411       jj_la1[90] = jj_gen;
3412       ;
3413     }
3414    if (initializer == null) {
3415     {if (true) return new VariableDeclaration(currentSegment,
3416                                   varName.toCharArray(),
3417                                   pos,
3418                                   SimpleCharStream.getPosition());}
3419    }
3420     {if (true) return new VariableDeclaration(currentSegment,
3421                                     varName.toCharArray(),
3422                                     initializer,
3423                                     VariableDeclaration.EQUAL,
3424                                     pos);}
3425     throw new Error("Missing return statement in function");
3426   }
3427
3428   static final public EmptyStatement EmptyStatement() throws ParseException {
3429   final int pos;
3430     jj_consume_token(SEMICOLON);
3431    pos = SimpleCharStream.getPosition();
3432    {if (true) return new EmptyStatement(pos-1,pos);}
3433     throw new Error("Missing return statement in function");
3434   }
3435
3436   static final public Expression StatementExpression() throws ParseException {
3437   final Expression expr,expr2;
3438   final int operator;
3439     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3440     case PLUS_PLUS:
3441     case MINUS_MINUS:
3442       expr = PreIncDecExpression();
3443                                 {if (true) return expr;}
3444       break;
3445     case ARRAY:
3446     case NEW:
3447     case IDENTIFIER:
3448       expr = PrimaryExpression();
3449       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3450       case PLUS_PLUS:
3451       case MINUS_MINUS:
3452         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3453         case PLUS_PLUS:
3454           jj_consume_token(PLUS_PLUS);
3455                  {if (true) return new PostfixedUnaryExpression(expr,
3456                                                 OperatorIds.PLUS_PLUS,
3457                                                 SimpleCharStream.getPosition());}
3458           break;
3459         case MINUS_MINUS:
3460           jj_consume_token(MINUS_MINUS);
3461                    {if (true) return new PostfixedUnaryExpression(expr,
3462                                                 OperatorIds.MINUS_MINUS,
3463                                                 SimpleCharStream.getPosition());}
3464           break;
3465         default:
3466           jj_la1[91] = jj_gen;
3467           jj_consume_token(-1);
3468           throw new ParseException();
3469         }
3470         break;
3471       default:
3472         jj_la1[92] = jj_gen;
3473         ;
3474       }
3475    {if (true) return expr;}
3476       break;
3477     default:
3478       jj_la1[93] = jj_gen;
3479       jj_consume_token(-1);
3480       throw new ParseException();
3481     }
3482     throw new Error("Missing return statement in function");
3483   }
3484
3485   static final public SwitchStatement SwitchStatement() throws ParseException {
3486   final Expression variable;
3487   final AbstractCase[] cases;
3488   final int pos = SimpleCharStream.getPosition();
3489     jj_consume_token(SWITCH);
3490     try {
3491       jj_consume_token(LPAREN);
3492     } catch (ParseException e) {
3493     errorMessage = "'(' expected after 'switch'";
3494     errorLevel   = ERROR;
3495     errorStart = SimpleCharStream.getPosition() - e.currentToken.next.image.length() + 1;
3496     errorEnd   = SimpleCharStream.getPosition() + 1;
3497     {if (true) throw e;}
3498     }
3499     try {
3500       variable = Expression();
3501     } catch (ParseException e) {
3502     if (errorMessage != null) {
3503       {if (true) throw e;}
3504     }
3505     errorMessage = "expression expected";
3506     errorLevel   = ERROR;
3507     errorStart = SimpleCharStream.getPosition() - e.currentToken.next.image.length() + 1;
3508     errorEnd   = SimpleCharStream.getPosition() + 1;
3509     {if (true) throw e;}
3510     }
3511     try {
3512       jj_consume_token(RPAREN);
3513     } catch (ParseException e) {
3514     errorMessage = "')' expected";
3515     errorLevel   = ERROR;
3516     errorStart = SimpleCharStream.getPosition() - e.currentToken.next.image.length() + 1;
3517     errorEnd   = SimpleCharStream.getPosition() + 1;
3518     {if (true) throw e;}
3519     }
3520     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3521     case LBRACE:
3522       cases = switchStatementBrace();
3523       break;
3524     case COLON:
3525       cases = switchStatementColon(pos, pos + 6);
3526       break;
3527     default:
3528       jj_la1[94] = jj_gen;
3529       jj_consume_token(-1);
3530       throw new ParseException();
3531     }
3532    {if (true) return new SwitchStatement(variable,cases,pos,SimpleCharStream.getPosition());}
3533     throw new Error("Missing return statement in function");
3534   }
3535
3536   static final public AbstractCase[] switchStatementBrace() throws ParseException {
3537   AbstractCase cas;
3538   final ArrayList cases = new ArrayList();
3539     jj_consume_token(LBRACE);
3540     label_28:
3541     while (true) {
3542       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3543       case CASE:
3544       case _DEFAULT:
3545         ;
3546         break;
3547       default:
3548         jj_la1[95] = jj_gen;
3549         break label_28;
3550       }
3551       cas = switchLabel0();
3552                          cases.add(cas);
3553     }
3554     try {
3555       jj_consume_token(RBRACE);
3556     final AbstractCase[] abcase = new AbstractCase[cases.size()];
3557     cases.toArray(abcase);
3558     {if (true) return abcase;}
3559     } catch (ParseException e) {
3560     errorMessage = "'}' expected";
3561     errorLevel   = ERROR;
3562     errorStart = SimpleCharStream.getPosition() - e.currentToken.next.image.length() + 1;
3563     errorEnd   = SimpleCharStream.getPosition() + 1;
3564     {if (true) throw e;}
3565     }
3566     throw new Error("Missing return statement in function");
3567   }
3568
3569 /**
3570  * A Switch statement with : ... endswitch;
3571  * @param start the begin offset of the switch
3572  * @param end the end offset of the switch
3573  */
3574   static final public AbstractCase[] switchStatementColon(final int start, final int end) throws ParseException {
3575   AbstractCase cas;
3576   final ArrayList cases = new ArrayList();
3577     jj_consume_token(COLON);
3578    try {
3579   setMarker(fileToParse,
3580             "Ugly syntax detected, you should switch () {...} instead of switch (): ... enswitch;",
3581             start,
3582             end,
3583             INFO,
3584             "Line " + token.beginLine);
3585   } catch (CoreException e) {
3586     PHPeclipsePlugin.log(e);
3587   }
3588     label_29:
3589     while (true) {
3590       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3591       case CASE:
3592       case _DEFAULT:
3593         ;
3594         break;
3595       default:
3596         jj_la1[96] = jj_gen;
3597         break label_29;
3598       }
3599       cas = switchLabel0();
3600                           cases.add(cas);
3601     }
3602     try {
3603       jj_consume_token(ENDSWITCH);
3604     } catch (ParseException e) {
3605     errorMessage = "'endswitch' expected";
3606     errorLevel   = ERROR;
3607     errorStart = SimpleCharStream.getPosition() - e.currentToken.next.image.length() + 1;
3608     errorEnd   = SimpleCharStream.getPosition() + 1;
3609     {if (true) throw e;}
3610     }
3611     try {
3612       jj_consume_token(SEMICOLON);
3613     final AbstractCase[] abcase = new AbstractCase[cases.size()];
3614     cases.toArray(abcase);
3615     {if (true) return abcase;}
3616     } catch (ParseException e) {
3617     errorMessage = "';' expected after 'endswitch' keyword";
3618     errorLevel   = ERROR;
3619     errorStart = SimpleCharStream.getPosition() - e.currentToken.next.image.length() + 1;
3620     errorEnd   = SimpleCharStream.getPosition() + 1;
3621     {if (true) throw e;}
3622     }
3623     throw new Error("Missing return statement in function");
3624   }
3625
3626   static final public AbstractCase switchLabel0() throws ParseException {
3627   final Expression expr;
3628   Statement statement;
3629   final ArrayList stmts = new ArrayList();
3630   final int pos = SimpleCharStream.getPosition();
3631     expr = SwitchLabel();
3632     label_30:
3633     while (true) {
3634       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3635       case PHPEND:
3636       case CLASS:
3637       case FUNCTION:
3638       case IF:
3639       case ARRAY:
3640       case LIST:
3641       case PRINT:
3642       case ECHO:
3643       case INCLUDE:
3644       case REQUIRE:
3645       case INCLUDE_ONCE:
3646       case REQUIRE_ONCE:
3647       case GLOBAL:
3648       case DEFINE:
3649       case STATIC:
3650       case CONTINUE:
3651       case DO:
3652       case FOR:
3653       case NEW:
3654       case NULL:
3655       case RETURN:
3656       case SWITCH:
3657       case TRUE:
3658       case FALSE:
3659       case WHILE:
3660       case FOREACH:
3661       case AT:
3662       case DOLLAR:
3663       case BANG:
3664       case PLUS_PLUS:
3665       case MINUS_MINUS:
3666       case PLUS:
3667       case MINUS:
3668       case BIT_AND:
3669       case INTEGER_LITERAL:
3670       case FLOATING_POINT_LITERAL:
3671       case STRING_LITERAL:
3672       case IDENTIFIER:
3673       case LPAREN:
3674       case LBRACE:
3675       case SEMICOLON:
3676       case DOLLAR_ID:
3677         ;
3678         break;
3679       default:
3680         jj_la1[97] = jj_gen;
3681         break label_30;
3682       }
3683       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3684       case CLASS:
3685       case FUNCTION:
3686       case IF:
3687       case ARRAY:
3688       case LIST:
3689       case PRINT:
3690       case ECHO:
3691       case INCLUDE:
3692       case REQUIRE:
3693       case INCLUDE_ONCE:
3694       case REQUIRE_ONCE:
3695       case GLOBAL:
3696       case DEFINE:
3697       case STATIC:
3698       case CONTINUE:
3699       case DO:
3700       case FOR:
3701       case NEW:
3702       case NULL:
3703       case RETURN:
3704       case SWITCH:
3705       case TRUE:
3706       case FALSE:
3707       case WHILE:
3708       case FOREACH:
3709       case AT:
3710       case DOLLAR:
3711       case BANG:
3712       case PLUS_PLUS:
3713       case MINUS_MINUS:
3714       case PLUS:
3715       case MINUS:
3716       case BIT_AND:
3717       case INTEGER_LITERAL:
3718       case FLOATING_POINT_LITERAL:
3719       case STRING_LITERAL:
3720       case IDENTIFIER:
3721       case LPAREN:
3722       case LBRACE:
3723       case SEMICOLON:
3724       case DOLLAR_ID:
3725         statement = BlockStatementNoBreak();
3726                                          stmts.add(statement);
3727         break;
3728       case PHPEND:
3729         statement = htmlBlock();
3730                                          stmts.add(statement);
3731         break;
3732       default:
3733         jj_la1[98] = jj_gen;
3734         jj_consume_token(-1);
3735         throw new ParseException();
3736       }
3737     }
3738     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3739     case BREAK:
3740       statement = BreakStatement();
3741                                          stmts.add(statement);
3742       break;
3743     default:
3744       jj_la1[99] = jj_gen;
3745       ;
3746     }
3747   final Statement[] stmtsArray = new Statement[stmts.size()];
3748   stmts.toArray(stmtsArray);
3749   if (expr == null) {//it's a default
3750     {if (true) return new DefaultCase(stmtsArray,pos,SimpleCharStream.getPosition());}
3751   }
3752   {if (true) return new Case(expr,stmtsArray,pos,SimpleCharStream.getPosition());}
3753     throw new Error("Missing return statement in function");
3754   }
3755
3756 /**
3757  * A SwitchLabel.
3758  * case Expression() :
3759  * default :
3760  * @return the if it was a case and null if not
3761  */
3762   static final public Expression SwitchLabel() throws ParseException {
3763   final Expression expr;
3764     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3765     case CASE:
3766       token = jj_consume_token(CASE);
3767       try {
3768         expr = Expression();
3769       } catch (ParseException e) {
3770     if (errorMessage != null) {if (true) throw e;}
3771     errorMessage = "expression expected after 'case' keyword";
3772     errorLevel   = ERROR;
3773     errorStart = SimpleCharStream.getPosition() - e.currentToken.next.image.length() + 1;
3774     errorEnd   = SimpleCharStream.getPosition() + 1;
3775     {if (true) throw e;}
3776       }
3777       try {
3778         jj_consume_token(COLON);
3779      {if (true) return expr;}
3780       } catch (ParseException e) {
3781     errorMessage = "':' expected after case expression";
3782     errorLevel   = ERROR;
3783     errorStart = SimpleCharStream.getPosition() - e.currentToken.next.image.length() + 1;
3784     errorEnd   = SimpleCharStream.getPosition() + 1;
3785     {if (true) throw e;}
3786       }
3787       break;
3788     case _DEFAULT:
3789       token = jj_consume_token(_DEFAULT);
3790       try {
3791         jj_consume_token(COLON);
3792      {if (true) return null;}
3793       } catch (ParseException e) {
3794     errorMessage = "':' expected after 'default' keyword";
3795     errorLevel   = ERROR;
3796     errorStart = SimpleCharStream.getPosition() - e.currentToken.next.image.length() + 1;
3797     errorEnd   = SimpleCharStream.getPosition() + 1;
3798     {if (true) throw e;}
3799       }
3800       break;
3801     default:
3802       jj_la1[100] = jj_gen;
3803       jj_consume_token(-1);
3804       throw new ParseException();
3805     }
3806     throw new Error("Missing return statement in function");
3807   }
3808
3809   static final public Break BreakStatement() throws ParseException {
3810   Expression expression = null;
3811   final int start = SimpleCharStream.getPosition();
3812     jj_consume_token(BREAK);
3813     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3814     case ARRAY:
3815     case LIST:
3816     case PRINT:
3817     case NEW:
3818     case NULL:
3819     case TRUE:
3820     case FALSE:
3821     case AT:
3822     case DOLLAR:
3823     case BANG:
3824     case PLUS_PLUS:
3825     case MINUS_MINUS:
3826     case PLUS:
3827     case MINUS:
3828     case BIT_AND:
3829     case INTEGER_LITERAL:
3830     case FLOATING_POINT_LITERAL:
3831     case STRING_LITERAL:
3832     case IDENTIFIER:
3833     case LPAREN:
3834     case DOLLAR_ID:
3835       expression = Expression();
3836       break;
3837     default:
3838       jj_la1[101] = jj_gen;
3839       ;
3840     }
3841     try {
3842       jj_consume_token(SEMICOLON);
3843     } catch (ParseException e) {
3844     errorMessage = "';' expected after 'break' keyword";
3845     errorLevel   = ERROR;
3846     errorStart = SimpleCharStream.getPosition() - e.currentToken.next.image.length() + 1;
3847     errorEnd   = SimpleCharStream.getPosition() + 1;
3848     {if (true) throw e;}
3849     }
3850    {if (true) return new Break(expression, start, SimpleCharStream.getPosition());}
3851     throw new Error("Missing return statement in function");
3852   }
3853
3854   static final public IfStatement IfStatement() throws ParseException {
3855   final int pos = SimpleCharStream.getPosition();
3856   final Expression condition;
3857   final IfStatement ifStatement;
3858     jj_consume_token(IF);
3859     condition = Condition("if");
3860     ifStatement = IfStatement0(condition, pos,pos+2);
3861    {if (true) return ifStatement;}
3862     throw new Error("Missing return statement in function");
3863   }
3864
3865   static final public Expression Condition(final String keyword) throws ParseException {
3866   final Expression condition;
3867     try {
3868       jj_consume_token(LPAREN);
3869     } catch (ParseException e) {
3870     errorMessage = "'(' expected after " + keyword + " keyword";
3871     errorLevel   = ERROR;
3872     errorStart = SimpleCharStream.getPosition() - e.currentToken.next.image.length();
3873     errorEnd   = errorStart +1;
3874     processParseException(e);
3875     }
3876     condition = Expression();
3877     try {
3878       jj_consume_token(RPAREN);
3879     } catch (ParseException e) {
3880     errorMessage = "')' expected after " + keyword + " keyword";
3881     errorLevel   = ERROR;
3882     errorStart = SimpleCharStream.getPosition() - e.currentToken.next.image.length() + 1;
3883     errorEnd   = SimpleCharStream.getPosition() + 1;
3884     processParseException(e);
3885     }
3886    {if (true) return condition;}
3887     throw new Error("Missing return statement in function");
3888   }
3889
3890   static final public IfStatement IfStatement0(final Expression condition, final int start,final int end) throws ParseException {
3891   Statement statement;
3892   final Statement stmt;
3893   final Statement[] statementsArray;
3894   ElseIf elseifStatement;
3895   Else elseStatement = null;
3896   final ArrayList stmts;
3897   final ArrayList elseIfList = new ArrayList();
3898   final ElseIf[] elseIfs;
3899   int pos = SimpleCharStream.getPosition();
3900   final int endStatements;
3901     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3902     case COLON:
3903       jj_consume_token(COLON);
3904    stmts = new ArrayList();
3905       label_31:
3906       while (true) {
3907         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3908         case PHPEND:
3909         case IF:
3910         case ARRAY:
3911         case BREAK:
3912         case LIST:
3913         case PRINT:
3914         case ECHO:
3915         case INCLUDE:
3916         case REQUIRE:
3917         case INCLUDE_ONCE:
3918         case REQUIRE_ONCE:
3919         case GLOBAL:
3920         case DEFINE:
3921         case STATIC:
3922         case CONTINUE:
3923         case DO:
3924         case FOR:
3925         case NEW:
3926         case NULL:
3927         case RETURN:
3928         case SWITCH:
3929         case TRUE:
3930         case FALSE:
3931         case WHILE:
3932         case FOREACH:
3933         case AT:
3934         case DOLLAR:
3935         case BANG:
3936         case PLUS_PLUS:
3937         case MINUS_MINUS:
3938         case PLUS:
3939         case MINUS:
3940         case BIT_AND:
3941         case INTEGER_LITERAL:
3942         case FLOATING_POINT_LITERAL:
3943         case STRING_LITERAL:
3944         case IDENTIFIER:
3945         case LPAREN:
3946         case LBRACE:
3947         case SEMICOLON:
3948         case DOLLAR_ID:
3949           ;
3950           break;
3951         default:
3952           jj_la1[102] = jj_gen;
3953           break label_31;
3954         }
3955         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3956         case IF:
3957         case ARRAY:
3958         case BREAK:
3959         case LIST:
3960         case PRINT:
3961         case ECHO:
3962         case INCLUDE:
3963         case REQUIRE:
3964         case INCLUDE_ONCE:
3965         case REQUIRE_ONCE:
3966         case GLOBAL:
3967         case DEFINE:
3968         case STATIC:
3969         case CONTINUE:
3970         case DO:
3971         case FOR:
3972         case NEW:
3973         case NULL:
3974         case RETURN:
3975         case SWITCH:
3976         case TRUE:
3977         case FALSE:
3978         case WHILE:
3979         case FOREACH:
3980         case AT:
3981         case DOLLAR:
3982         case BANG:
3983         case PLUS_PLUS:
3984         case MINUS_MINUS:
3985         case PLUS:
3986         case MINUS:
3987         case BIT_AND:
3988         case INTEGER_LITERAL:
3989         case FLOATING_POINT_LITERAL:
3990         case STRING_LITERAL:
3991         case IDENTIFIER:
3992         case LPAREN:
3993         case LBRACE:
3994         case SEMICOLON:
3995         case DOLLAR_ID:
3996           statement = Statement();
3997                               stmts.add(statement);
3998           break;
3999         case PHPEND:
4000           statement = htmlBlock();
4001                               stmts.add(statement);
4002           break;
4003         default:
4004           jj_la1[103] = jj_gen;
4005           jj_consume_token(-1);
4006           throw new ParseException();
4007         }
4008       }
4009     endStatements = SimpleCharStream.getPosition();
4010       label_32:
4011       while (true) {
4012         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
4013         case ELSEIF:
4014           ;
4015           break;
4016         default:
4017           jj_la1[104] = jj_gen;
4018           break label_32;
4019         }
4020         elseifStatement = ElseIfStatementColon();
4021                                               elseIfList.add(elseifStatement);
4022       }
4023       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
4024       case ELSE:
4025         elseStatement = ElseStatementColon();
4026         break;
4027       default:
4028         jj_la1[105] = jj_gen;
4029         ;
4030       }
4031    try {
4032   setMarker(fileToParse,
4033             "Ugly syntax detected, you should if () {...} instead of if (): ... endif;",
4034             start,
4035             end,
4036             INFO,
4037             "Line " + token.beginLine);
4038   } catch (CoreException e) {
4039     PHPeclipsePlugin.log(e);
4040   }
4041       try {
4042         jj_consume_token(ENDIF);
4043       } catch (ParseException e) {
4044     errorMessage = "'endif' expected";
4045     errorLevel   = ERROR;
4046     errorStart = SimpleCharStream.getPosition() - e.currentToken.next.image.length() + 1;
4047     errorEnd   = SimpleCharStream.getPosition() + 1;
4048     {if (true) throw e;}
4049       }
4050       try {
4051         jj_consume_token(SEMICOLON);
4052       } catch (ParseException e) {
4053     errorMessage = "';' expected after 'endif' keyword";
4054     errorLevel   = ERROR;
4055     errorStart = SimpleCharStream.getPosition() - e.currentToken.next.image.length() + 1;
4056     errorEnd   = SimpleCharStream.getPosition() + 1;
4057     {if (true) throw e;}
4058       }
4059     elseIfs = new ElseIf[elseIfList.size()];
4060     elseIfList.toArray(elseIfs);
4061     if (stmts.size() == 1) {
4062       {if (true) return new IfStatement(condition,
4063                              (Statement) stmts.get(0),
4064                               elseIfs,
4065                               elseStatement,
4066                               pos,
4067                               SimpleCharStream.getPosition());}
4068     } else {
4069       statementsArray = new Statement[stmts.size()];
4070       stmts.toArray(statementsArray);
4071       {if (true) return new IfStatement(condition,
4072                              new Block(statementsArray,pos,endStatements),
4073                              elseIfs,
4074                              elseStatement,
4075                              pos,
4076                              SimpleCharStream.getPosition());}
4077     }
4078       break;
4079     case PHPEND:
4080     case IF:
4081     case ARRAY:
4082     case BREAK:
4083     case LIST:
4084     case PRINT:
4085     case ECHO:
4086     case INCLUDE:
4087     case REQUIRE:
4088     case INCLUDE_ONCE:
4089     case REQUIRE_ONCE:
4090     case GLOBAL:
4091     case DEFINE:
4092     case STATIC:
4093     case CONTINUE:
4094     case DO:
4095     case FOR:
4096     case NEW:
4097     case NULL:
4098     case RETURN:
4099     case SWITCH:
4100     case TRUE:
4101     case FALSE:
4102     case WHILE:
4103     case FOREACH:
4104     case AT:
4105     case DOLLAR:
4106     case BANG:
4107     case PLUS_PLUS:
4108     case MINUS_MINUS:
4109     case PLUS:
4110     case MINUS:
4111     case BIT_AND:
4112     case INTEGER_LITERAL:
4113     case FLOATING_POINT_LITERAL:
4114     case STRING_LITERAL:
4115     case IDENTIFIER:
4116     case LPAREN:
4117     case LBRACE:
4118     case SEMICOLON:
4119     case DOLLAR_ID:
4120       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
4121       case IF:
4122       case ARRAY:
4123       case BREAK:
4124       case LIST:
4125       case PRINT:
4126       case ECHO:
4127       case INCLUDE:
4128       case REQUIRE:
4129       case INCLUDE_ONCE:
4130       case REQUIRE_ONCE:
4131       case GLOBAL:
4132       case DEFINE:
4133       case STATIC:
4134       case CONTINUE:
4135       case DO:
4136       case FOR:
4137       case NEW:
4138       case NULL:
4139       case RETURN:
4140       case SWITCH:
4141       case TRUE:
4142       case FALSE:
4143       case WHILE:
4144       case FOREACH:
4145       case AT:
4146       case DOLLAR:
4147       case BANG:
4148       case PLUS_PLUS:
4149       case MINUS_MINUS:
4150       case PLUS:
4151       case MINUS:
4152       case BIT_AND:
4153       case INTEGER_LITERAL:
4154       case FLOATING_POINT_LITERAL:
4155       case STRING_LITERAL:
4156       case IDENTIFIER:
4157       case LPAREN:
4158       case LBRACE:
4159       case SEMICOLON:
4160       case DOLLAR_ID:
4161         stmt = Statement();
4162         break;
4163       case PHPEND:
4164         stmt = htmlBlock();
4165         break;
4166       default:
4167         jj_la1[106] = jj_gen;
4168         jj_consume_token(-1);
4169         throw new ParseException();
4170       }
4171       label_33:
4172       while (true) {
4173         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
4174         case ELSEIF:
4175           ;
4176           break;
4177         default:
4178           jj_la1[107] = jj_gen;
4179           break label_33;
4180         }
4181         elseifStatement = ElseIfStatement();
4182                                                       elseIfList.add(elseifStatement);
4183       }
4184       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
4185       case ELSE:
4186         jj_consume_token(ELSE);
4187         try {
4188        pos = SimpleCharStream.getPosition();
4189           statement = Statement();
4190        elseStatement = new Else(statement,pos,SimpleCharStream.getPosition());
4191         } catch (ParseException e) {
4192       if (errorMessage != null) {
4193         {if (true) throw e;}
4194       }
4195       errorMessage = "unexpected token '"+e.currentToken.next.image+"', a statement was expected";
4196       errorLevel   = ERROR;
4197       errorStart = SimpleCharStream.getPosition() - e.currentToken.next.image.length() + 1;
4198       errorEnd   = SimpleCharStream.getPosition() + 1;
4199       {if (true) throw e;}
4200         }
4201         break;
4202       default:
4203         jj_la1[108] = jj_gen;
4204         ;
4205       }
4206     elseIfs = new ElseIf[elseIfList.size()];
4207     elseIfList.toArray(elseIfs);
4208     {if (true) return new IfStatement(condition,
4209                            stmt,
4210                            elseIfs,
4211                            elseStatement,
4212                            pos,
4213                            SimpleCharStream.getPosition());}
4214       break;
4215     default:
4216       jj_la1[109] = jj_gen;
4217       jj_consume_token(-1);
4218       throw new ParseException();
4219     }
4220     throw new Error("Missing return statement in function");
4221   }
4222
4223   static final public ElseIf ElseIfStatementColon() throws ParseException {
4224   final Expression condition;
4225   Statement statement;
4226   final ArrayList list = new ArrayList();
4227   final int pos = SimpleCharStream.getPosition();
4228     jj_consume_token(ELSEIF);
4229     condition = Condition("elseif");
4230     jj_consume_token(COLON);
4231     label_34:
4232     while (true) {
4233       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
4234       case PHPEND:
4235       case IF:
4236       case ARRAY:
4237       case BREAK:
4238       case LIST:
4239       case PRINT:
4240       case ECHO:
4241       case INCLUDE:
4242       case REQUIRE:
4243       case INCLUDE_ONCE:
4244       case REQUIRE_ONCE:
4245       case GLOBAL:
4246       case DEFINE:
4247       case STATIC:
4248       case CONTINUE:
4249       case DO:
4250       case FOR:
4251       case NEW:
4252       case NULL:
4253       case RETURN:
4254       case SWITCH:
4255       case TRUE:
4256       case FALSE:
4257       case WHILE:
4258       case FOREACH:
4259       case AT:
4260       case DOLLAR:
4261       case BANG:
4262       case PLUS_PLUS:
4263       case MINUS_MINUS:
4264       case PLUS:
4265       case MINUS:
4266       case BIT_AND:
4267       case INTEGER_LITERAL:
4268       case FLOATING_POINT_LITERAL:
4269       case STRING_LITERAL:
4270       case IDENTIFIER:
4271       case LPAREN:
4272       case LBRACE:
4273       case SEMICOLON:
4274       case DOLLAR_ID:
4275         ;
4276         break;
4277       default:
4278         jj_la1[110] = jj_gen;
4279         break label_34;
4280       }
4281       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
4282       case IF:
4283       case ARRAY:
4284       case BREAK:
4285       case LIST:
4286       case PRINT:
4287       case ECHO:
4288       case INCLUDE:
4289       case REQUIRE:
4290       case INCLUDE_ONCE:
4291       case REQUIRE_ONCE:
4292       case GLOBAL:
4293       case DEFINE:
4294       case STATIC:
4295       case CONTINUE:
4296       case DO:
4297       case FOR:
4298       case NEW:
4299       case NULL:
4300       case RETURN:
4301       case SWITCH:
4302       case TRUE:
4303       case FALSE:
4304       case WHILE:
4305       case FOREACH:
4306       case AT:
4307       case DOLLAR:
4308       case BANG:
4309       case PLUS_PLUS:
4310       case MINUS_MINUS:
4311       case PLUS:
4312       case MINUS:
4313       case BIT_AND:
4314       case INTEGER_LITERAL:
4315       case FLOATING_POINT_LITERAL:
4316       case STRING_LITERAL:
4317       case IDENTIFIER:
4318       case LPAREN:
4319       case LBRACE:
4320       case SEMICOLON:
4321       case DOLLAR_ID:
4322         statement = Statement();
4323                                       list.add(statement);
4324         break;
4325       case PHPEND:
4326         statement = htmlBlock();
4327                                       list.add(statement);
4328         break;
4329       default:
4330         jj_la1[111] = jj_gen;
4331         jj_consume_token(-1);
4332         throw new ParseException();
4333       }
4334     }
4335   final Statement[] stmtsArray = new Statement[list.size()];
4336   list.toArray(stmtsArray);
4337   {if (true) return new ElseIf(condition,stmtsArray ,pos,SimpleCharStream.getPosition());}
4338     throw new Error("Missing return statement in function");
4339   }
4340
4341   static final public Else ElseStatementColon() throws ParseException {
4342   Statement statement;
4343   final ArrayList list = new ArrayList();
4344   final int pos = SimpleCharStream.getPosition();
4345     jj_consume_token(ELSE);
4346     jj_consume_token(COLON);
4347     label_35:
4348     while (true) {
4349       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
4350       case PHPEND:
4351       case IF:
4352       case ARRAY:
4353       case BREAK:
4354       case LIST:
4355       case PRINT:
4356       case ECHO:
4357       case INCLUDE:
4358       case REQUIRE:
4359       case INCLUDE_ONCE:
4360       case REQUIRE_ONCE:
4361       case GLOBAL:
4362       case DEFINE:
4363       case STATIC:
4364       case CONTINUE:
4365       case DO:
4366       case FOR:
4367       case NEW:
4368       case NULL:
4369       case RETURN:
4370       case SWITCH:
4371       case TRUE:
4372       case FALSE:
4373       case WHILE:
4374       case FOREACH:
4375       case AT:
4376       case DOLLAR:
4377       case BANG:
4378       case PLUS_PLUS:
4379       case MINUS_MINUS:
4380       case PLUS:
4381       case MINUS:
4382       case BIT_AND:
4383       case INTEGER_LITERAL:
4384       case FLOATING_POINT_LITERAL:
4385       case STRING_LITERAL:
4386       case IDENTIFIER:
4387       case LPAREN:
4388       case LBRACE:
4389       case SEMICOLON:
4390       case DOLLAR_ID:
4391         ;
4392         break;
4393       default:
4394         jj_la1[112] = jj_gen;
4395         break label_35;
4396       }
4397       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
4398       case IF:
4399       case ARRAY:
4400       case BREAK:
4401       case LIST:
4402       case PRINT:
4403       case ECHO:
4404       case INCLUDE:
4405       case REQUIRE:
4406       case INCLUDE_ONCE:
4407       case REQUIRE_ONCE:
4408       case GLOBAL:
4409       case DEFINE:
4410       case STATIC:
4411       case CONTINUE:
4412       case DO:
4413       case FOR:
4414       case NEW:
4415       case NULL:
4416       case RETURN:
4417       case SWITCH:
4418       case TRUE:
4419       case FALSE:
4420       case WHILE:
4421       case FOREACH:
4422       case AT:
4423       case DOLLAR:
4424       case BANG:
4425       case PLUS_PLUS:
4426       case MINUS_MINUS:
4427       case PLUS:
4428       case MINUS:
4429       case BIT_AND:
4430       case INTEGER_LITERAL:
4431       case FLOATING_POINT_LITERAL:
4432       case STRING_LITERAL:
4433       case IDENTIFIER:
4434       case LPAREN:
4435       case LBRACE:
4436       case SEMICOLON:
4437       case DOLLAR_ID:
4438         statement = Statement();
4439                                              list.add(statement);
4440         break;
4441       case PHPEND:
4442         statement = htmlBlock();
4443                                              list.add(statement);
4444         break;
4445       default:
4446         jj_la1[113] = jj_gen;
4447         jj_consume_token(-1);
4448         throw new ParseException();
4449       }
4450     }
4451   final Statement[] stmtsArray = new Statement[list.size()];
4452   list.toArray(stmtsArray);
4453   {if (true) return new Else(stmtsArray,pos,SimpleCharStream.getPosition());}
4454     throw new Error("Missing return statement in function");
4455   }
4456
4457   static final public ElseIf ElseIfStatement() throws ParseException {
4458   final Expression condition;
4459   final Statement statement;
4460   final ArrayList list = new ArrayList();
4461   final int pos = SimpleCharStream.getPosition();
4462     jj_consume_token(ELSEIF);
4463     condition = Condition("elseif");
4464     statement = Statement();
4465                                                                     list.add(statement);/*todo:do better*/
4466   final Statement[] stmtsArray = new Statement[list.size()];
4467   list.toArray(stmtsArray);
4468   {if (true) return new ElseIf(condition,stmtsArray,pos,SimpleCharStream.getPosition());}
4469     throw new Error("Missing return statement in function");
4470   }
4471
4472   static final public WhileStatement WhileStatement() throws ParseException {
4473   final Expression condition;
4474   final Statement action;
4475   final int pos = SimpleCharStream.getPosition();
4476     jj_consume_token(WHILE);
4477     condition = Condition("while");
4478     action = WhileStatement0(pos,pos + 5);
4479      {if (true) return new WhileStatement(condition,action,pos,SimpleCharStream.getPosition());}
4480     throw new Error("Missing return statement in function");
4481   }
4482
4483   static final public Statement WhileStatement0(final int start, final int end) throws ParseException {
4484   Statement statement;
4485   final ArrayList stmts = new ArrayList();
4486   final int pos = SimpleCharStream.getPosition();
4487     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
4488     case COLON:
4489       jj_consume_token(COLON);
4490       label_36:
4491       while (true) {
4492         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
4493         case IF:
4494         case ARRAY:
4495         case BREAK:
4496         case LIST:
4497         case PRINT:
4498         case ECHO:
4499         case INCLUDE:
4500         case REQUIRE:
4501         case INCLUDE_ONCE:
4502         case REQUIRE_ONCE:
4503         case GLOBAL:
4504         case DEFINE:
4505         case STATIC:
4506         case CONTINUE:
4507         case DO:
4508         case FOR:
4509         case NEW:
4510         case NULL:
4511         case RETURN:
4512         case SWITCH:
4513         case TRUE:
4514         case FALSE:
4515         case WHILE:
4516         case FOREACH:
4517         case AT:
4518         case DOLLAR:
4519         case BANG:
4520         case PLUS_PLUS:
4521         case MINUS_MINUS:
4522         case PLUS:
4523         case MINUS:
4524         case BIT_AND:
4525         case INTEGER_LITERAL:
4526         case FLOATING_POINT_LITERAL:
4527         case STRING_LITERAL:
4528         case IDENTIFIER:
4529         case LPAREN:
4530         case LBRACE:
4531         case SEMICOLON:
4532         case DOLLAR_ID:
4533           ;
4534           break;
4535         default:
4536           jj_la1[114] = jj_gen;
4537           break label_36;
4538         }
4539         statement = Statement();
4540                                     stmts.add(statement);
4541       }
4542    try {
4543   setMarker(fileToParse,
4544             "Ugly syntax detected, you should while () {...} instead of while (): ... endwhile;",
4545             start,
4546             end,
4547             INFO,
4548             "Line " + token.beginLine);
4549   } catch (CoreException e) {
4550     PHPeclipsePlugin.log(e);
4551   }
4552       try {
4553         jj_consume_token(ENDWHILE);
4554       } catch (ParseException e) {
4555     errorMessage = "'endwhile' expected";
4556     errorLevel   = ERROR;
4557     errorStart = SimpleCharStream.getPosition() - e.currentToken.next.image.length() + 1;
4558     errorEnd   = SimpleCharStream.getPosition() + 1;
4559     {if (true) throw e;}
4560       }
4561       try {
4562         jj_consume_token(SEMICOLON);
4563     final Statement[] stmtsArray = new Statement[stmts.size()];
4564     stmts.toArray(stmtsArray);
4565     {if (true) return new Block(stmtsArray,pos,SimpleCharStream.getPosition());}
4566       } catch (ParseException e) {
4567     errorMessage = "';' expected after 'endwhile' keyword";
4568     errorLevel   = ERROR;
4569     errorStart = SimpleCharStream.getPosition() - e.currentToken.next.image.length() + 1;
4570     errorEnd   = SimpleCharStream.getPosition() + 1;
4571     {if (true) throw e;}
4572       }
4573       break;
4574     case IF:
4575     case ARRAY:
4576     case BREAK:
4577     case LIST:
4578     case PRINT:
4579     case ECHO:
4580     case INCLUDE:
4581     case REQUIRE:
4582     case INCLUDE_ONCE:
4583     case REQUIRE_ONCE:
4584     case GLOBAL:
4585     case DEFINE:
4586     case STATIC:
4587     case CONTINUE:
4588     case DO:
4589     case FOR:
4590     case NEW:
4591     case NULL:
4592     case RETURN:
4593     case SWITCH:
4594     case TRUE:
4595     case FALSE:
4596     case WHILE:
4597     case FOREACH:
4598     case AT:
4599     case DOLLAR:
4600     case BANG:
4601     case PLUS_PLUS:
4602     case MINUS_MINUS:
4603     case PLUS:
4604     case MINUS:
4605     case BIT_AND:
4606     case INTEGER_LITERAL:
4607     case FLOATING_POINT_LITERAL:
4608     case STRING_LITERAL:
4609     case IDENTIFIER:
4610     case LPAREN:
4611     case LBRACE:
4612     case SEMICOLON:
4613     case DOLLAR_ID:
4614       statement = Statement();
4615    {if (true) return statement;}
4616       break;
4617     default:
4618       jj_la1[115] = jj_gen;
4619       jj_consume_token(-1);
4620       throw new ParseException();
4621     }
4622     throw new Error("Missing return statement in function");
4623   }
4624
4625   static final public DoStatement DoStatement() throws ParseException {
4626   final Statement action;
4627   final Expression condition;
4628   final int pos = SimpleCharStream.getPosition();
4629     jj_consume_token(DO);
4630     action = Statement();
4631     jj_consume_token(WHILE);
4632     condition = Condition("while");
4633     try {
4634       jj_consume_token(SEMICOLON);
4635      {if (true) return new DoStatement(condition,action,pos,SimpleCharStream.getPosition());}
4636     } catch (ParseException e) {
4637     errorMessage = "unexpected token : '"+ e.currentToken.next.image +"'. A ';' was expected";
4638     errorLevel   = ERROR;
4639     errorStart = SimpleCharStream.getPosition() - e.currentToken.next.image.length() + 1;
4640     errorEnd   = SimpleCharStream.getPosition() + 1;
4641     {if (true) throw e;}
4642     }
4643     throw new Error("Missing return statement in function");
4644   }
4645
4646   static final public ForeachStatement ForeachStatement() throws ParseException {
4647   Statement statement;
4648   Expression expression;
4649   final int pos = SimpleCharStream.getPosition();
4650   ArrayVariableDeclaration variable;
4651     jj_consume_token(FOREACH);
4652     try {
4653       jj_consume_token(LPAREN);
4654     } catch (ParseException e) {
4655     errorMessage = "'(' expected after 'foreach' keyword";
4656     errorLevel   = ERROR;
4657     errorStart = SimpleCharStream.getPosition() - e.currentToken.next.image.length() + 1;
4658     errorEnd   = SimpleCharStream.getPosition() + 1;
4659     {if (true) throw e;}
4660     }
4661     try {
4662       expression = Expression();
4663     } catch (ParseException e) {
4664     errorMessage = "variable expected";
4665     errorLevel   = ERROR;
4666     errorStart = SimpleCharStream.getPosition() - e.currentToken.next.image.length() + 1;
4667     errorEnd   = SimpleCharStream.getPosition() + 1;
4668     {if (true) throw e;}
4669     }
4670     try {
4671       jj_consume_token(AS);
4672     } catch (ParseException e) {
4673     errorMessage = "'as' expected";
4674     errorLevel   = ERROR;
4675     errorStart = SimpleCharStream.getPosition() - e.currentToken.next.image.length() + 1;
4676     errorEnd   = SimpleCharStream.getPosition() + 1;
4677     {if (true) throw e;}
4678     }
4679     try {
4680       variable = ArrayVariable();
4681     } catch (ParseException e) {
4682     errorMessage = "variable expected";
4683     errorLevel   = ERROR;
4684     errorStart = SimpleCharStream.getPosition() - e.currentToken.next.image.length() + 1;
4685     errorEnd   = SimpleCharStream.getPosition() + 1;
4686     {if (true) throw e;}
4687     }
4688     try {
4689       jj_consume_token(RPAREN);
4690     } catch (ParseException e) {
4691     errorMessage = "')' expected after 'foreach' keyword";
4692     errorLevel   = ERROR;
4693     errorStart = SimpleCharStream.getPosition() - e.currentToken.next.image.length() + 1;
4694     errorEnd   = SimpleCharStream.getPosition() + 1;
4695     {if (true) throw e;}
4696     }
4697     try {
4698       statement = Statement();
4699     } catch (ParseException e) {
4700     if (errorMessage != null) {if (true) throw e;}
4701     errorMessage = "statement expected";
4702     errorLevel   = ERROR;
4703     errorStart = SimpleCharStream.getPosition() - e.currentToken.next.image.length() + 1;
4704     errorEnd   = SimpleCharStream.getPosition() + 1;
4705     {if (true) throw e;}
4706     }
4707    {if (true) return new ForeachStatement(expression,
4708                                variable,
4709                                statement,
4710                                pos,
4711                                SimpleCharStream.getPosition());}
4712     throw new Error("Missing return statement in function");
4713   }
4714
4715   static final public ForStatement ForStatement() throws ParseException {
4716 final Token token;
4717 final int pos = SimpleCharStream.getPosition();
4718 Expression[] initializations = null;
4719 Expression condition = null;
4720 Expression[] increments = null;
4721 Statement action;
4722 final ArrayList list = new ArrayList();
4723 final int startBlock, endBlock;
4724     token = jj_consume_token(FOR);
4725     try {
4726       jj_consume_token(LPAREN);
4727     } catch (ParseException e) {
4728     errorMessage = "'(' expected after 'for' keyword";
4729     errorLevel   = ERROR;
4730     errorStart = SimpleCharStream.getPosition() - e.currentToken.next.image.length() + 1;
4731     errorEnd   = SimpleCharStream.getPosition() + 1;
4732     {if (true) throw e;}
4733     }
4734     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
4735     case ARRAY:
4736     case NEW:
4737     case DOLLAR:
4738     case PLUS_PLUS:
4739     case MINUS_MINUS:
4740     case IDENTIFIER:
4741     case DOLLAR_ID:
4742       initializations = ForInit();
4743       break;
4744     default:
4745       jj_la1[116] = jj_gen;
4746       ;
4747     }
4748     jj_consume_token(SEMICOLON);
4749     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
4750     case ARRAY:
4751     case LIST:
4752     case PRINT:
4753     case NEW:
4754     case NULL:
4755     case TRUE:
4756     case FALSE:
4757     case AT:
4758     case DOLLAR:
4759     case BANG:
4760     case PLUS_PLUS:
4761     case MINUS_MINUS:
4762     case PLUS:
4763     case MINUS:
4764     case BIT_AND:
4765     case INTEGER_LITERAL:
4766     case FLOATING_POINT_LITERAL:
4767     case STRING_LITERAL:
4768     case IDENTIFIER:
4769     case LPAREN:
4770     case DOLLAR_ID:
4771       condition = Expression();
4772       break;
4773     default:
4774       jj_la1[117] = jj_gen;
4775       ;
4776     }
4777     jj_consume_token(SEMICOLON);
4778     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
4779     case ARRAY:
4780     case NEW:
4781     case PLUS_PLUS:
4782     case MINUS_MINUS:
4783     case IDENTIFIER:
4784       increments = StatementExpressionList();
4785       break;
4786     default:
4787       jj_la1[118] = jj_gen;
4788       ;
4789     }
4790     jj_consume_token(RPAREN);
4791     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
4792     case IF:
4793     case ARRAY:
4794     case BREAK:
4795     case LIST:
4796     case PRINT:
4797     case ECHO:
4798     case INCLUDE:
4799     case REQUIRE:
4800     case INCLUDE_ONCE:
4801     case REQUIRE_ONCE:
4802     case GLOBAL:
4803     case DEFINE:
4804     case STATIC:
4805     case CONTINUE:
4806     case DO:
4807     case FOR:
4808     case NEW:
4809     case NULL:
4810     case RETURN:
4811     case SWITCH:
4812     case TRUE:
4813     case FALSE:
4814     case WHILE:
4815     case FOREACH:
4816     case AT:
4817     case DOLLAR:
4818     case BANG:
4819     case PLUS_PLUS:
4820     case MINUS_MINUS:
4821     case PLUS:
4822     case MINUS:
4823     case BIT_AND:
4824     case INTEGER_LITERAL:
4825     case FLOATING_POINT_LITERAL:
4826     case STRING_LITERAL:
4827     case IDENTIFIER:
4828     case LPAREN:
4829     case LBRACE:
4830     case SEMICOLON:
4831     case DOLLAR_ID:
4832       action = Statement();
4833        {if (true) return new ForStatement(initializations,condition,increments,action,pos,SimpleCharStream.getPosition());}
4834       break;
4835     case COLON:
4836       jj_consume_token(COLON);
4837        startBlock = SimpleCharStream.getPosition();
4838       label_37:
4839       while (true) {
4840         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
4841         case IF:
4842         case ARRAY:
4843         case BREAK:
4844         case LIST:
4845         case PRINT:
4846         case ECHO:
4847         case INCLUDE:
4848         case REQUIRE:
4849         case INCLUDE_ONCE:
4850         case REQUIRE_ONCE:
4851         case GLOBAL:
4852         case DEFINE:
4853         case STATIC:
4854         case CONTINUE:
4855         case DO:
4856         case FOR:
4857         case NEW:
4858         case NULL:
4859         case RETURN:
4860         case SWITCH:
4861         case TRUE:
4862         case FALSE:
4863         case WHILE:
4864         case FOREACH:
4865         case AT:
4866         case DOLLAR:
4867         case BANG:
4868         case PLUS_PLUS:
4869         case MINUS_MINUS:
4870         case PLUS:
4871         case MINUS:
4872         case BIT_AND:
4873         case INTEGER_LITERAL:
4874         case FLOATING_POINT_LITERAL:
4875         case STRING_LITERAL:
4876         case IDENTIFIER:
4877         case LPAREN:
4878         case LBRACE:
4879         case SEMICOLON:
4880         case DOLLAR_ID:
4881           ;
4882           break;
4883         default:
4884           jj_la1[119] = jj_gen;
4885           break label_37;
4886         }
4887         action = Statement();
4888                              list.add(action);
4889       }
4890         try {
4891         setMarker(fileToParse,
4892                   "Ugly syntax detected, you should for () {...} instead of for (): ... endfor;",
4893                   pos,
4894                   pos+token.image.length(),
4895                   INFO,
4896                   "Line " + token.beginLine);
4897         } catch (CoreException e) {
4898           PHPeclipsePlugin.log(e);
4899         }
4900        endBlock = SimpleCharStream.getPosition();
4901       try {
4902         jj_consume_token(ENDFOR);
4903       } catch (ParseException e) {
4904         errorMessage = "'endfor' expected";
4905         errorLevel   = ERROR;
4906         errorStart = SimpleCharStream.getPosition() - e.currentToken.next.image.length() + 1;
4907         errorEnd   = SimpleCharStream.getPosition() + 1;
4908         {if (true) throw e;}
4909       }
4910       try {
4911         jj_consume_token(SEMICOLON);
4912         final Statement[] stmtsArray = new Statement[list.size()];
4913         list.toArray(stmtsArray);
4914         {if (true) return new ForStatement(initializations,condition,increments,new Block(stmtsArray,startBlock,endBlock),pos,SimpleCharStream.getPosition());}
4915       } catch (ParseException e) {
4916         errorMessage = "';' expected after 'endfor' keyword";
4917         errorLevel   = ERROR;
4918         errorStart = SimpleCharStream.getPosition() - e.currentToken.next.image.length() + 1;
4919         errorEnd   = SimpleCharStream.getPosition() + 1;
4920         {if (true) throw e;}
4921       }
4922       break;
4923     default:
4924       jj_la1[120] = jj_gen;
4925       jj_consume_token(-1);
4926       throw new ParseException();
4927     }
4928     throw new Error("Missing return statement in function");
4929   }
4930
4931   static final public Expression[] ForInit() throws ParseException {
4932   final Expression[] exprs;
4933     if (jj_2_5(2147483647)) {
4934       exprs = LocalVariableDeclaration();
4935    {if (true) return exprs;}
4936     } else {
4937       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
4938       case ARRAY:
4939       case NEW:
4940       case PLUS_PLUS:
4941       case MINUS_MINUS:
4942       case IDENTIFIER:
4943         exprs = StatementExpressionList();
4944    {if (true) return exprs;}
4945         break;
4946       default:
4947         jj_la1[121] = jj_gen;
4948         jj_consume_token(-1);
4949         throw new ParseException();
4950       }
4951     }
4952     throw new Error("Missing return statement in function");
4953   }
4954
4955   static final public Expression[] StatementExpressionList() throws ParseException {
4956   final ArrayList list = new ArrayList();
4957   final Expression expr;
4958     expr = StatementExpression();
4959                                   list.add(expr);
4960     label_38:
4961     while (true) {
4962       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
4963       case COMMA:
4964         ;
4965         break;
4966       default:
4967         jj_la1[122] = jj_gen;
4968         break label_38;
4969       }
4970       jj_consume_token(COMMA);
4971       StatementExpression();
4972                                   list.add(expr);
4973     }
4974   final Expression[] exprsArray = new Expression[list.size()];
4975   list.toArray(exprsArray);
4976   {if (true) return exprsArray;}
4977     throw new Error("Missing return statement in function");
4978   }
4979
4980   static final public Continue ContinueStatement() throws ParseException {
4981   Expression expr = null;
4982   final int pos = SimpleCharStream.getPosition();
4983     jj_consume_token(CONTINUE);
4984     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
4985     case ARRAY:
4986     case LIST:
4987     case PRINT:
4988     case NEW:
4989     case NULL:
4990     case TRUE:
4991     case FALSE:
4992     case AT:
4993     case DOLLAR:
4994     case BANG:
4995     case PLUS_PLUS:
4996     case MINUS_MINUS:
4997     case PLUS:
4998     case MINUS:
4999     case BIT_AND:
5000     case INTEGER_LITERAL:
5001     case FLOATING_POINT_LITERAL:
5002     case STRING_LITERAL:
5003     case IDENTIFIER:
5004     case LPAREN:
5005     case DOLLAR_ID:
5006       expr = Expression();
5007       break;
5008     default:
5009       jj_la1[123] = jj_gen;
5010       ;
5011     }
5012     try {
5013       jj_consume_token(SEMICOLON);
5014      {if (true) return new Continue(expr,pos,SimpleCharStream.getPosition());}
5015     } catch (ParseException e) {
5016     errorMessage = "';' expected after 'continue' statement";
5017     errorLevel   = ERROR;
5018     errorStart = SimpleCharStream.getPosition() - e.currentToken.next.image.length() + 1;
5019     errorEnd   = SimpleCharStream.getPosition() + 1;
5020     {if (true) throw e;}
5021     }
5022     throw new Error("Missing return statement in function");
5023   }
5024
5025   static final public ReturnStatement ReturnStatement() throws ParseException {
5026   Expression expr = null;
5027   final int pos = SimpleCharStream.getPosition();
5028     jj_consume_token(RETURN);
5029     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
5030     case ARRAY:
5031     case LIST:
5032     case PRINT:
5033     case NEW:
5034     case NULL:
5035     case TRUE:
5036     case FALSE:
5037     case AT:
5038     case DOLLAR:
5039     case BANG:
5040     case PLUS_PLUS:
5041     case MINUS_MINUS:
5042     case PLUS:
5043     case MINUS:
5044     case BIT_AND:
5045     case INTEGER_LITERAL:
5046     case FLOATING_POINT_LITERAL:
5047     case STRING_LITERAL:
5048     case IDENTIFIER:
5049     case LPAREN:
5050     case DOLLAR_ID:
5051       expr = Expression();
5052       break;
5053     default:
5054       jj_la1[124] = jj_gen;
5055       ;
5056     }
5057     try {
5058       jj_consume_token(SEMICOLON);
5059      {if (true) return new ReturnStatement(expr,pos,SimpleCharStream.getPosition());}
5060     } catch (ParseException e) {
5061     errorMessage = "';' expected after 'return' statement";
5062     errorLevel   = ERROR;
5063     errorStart = SimpleCharStream.getPosition() - e.currentToken.next.image.length() + 1;
5064     errorEnd   = SimpleCharStream.getPosition() + 1;
5065     {if (true) throw e;}
5066     }
5067     throw new Error("Missing return statement in function");
5068   }
5069
5070   static final private boolean jj_2_1(int xla) {
5071     jj_la = xla; jj_lastpos = jj_scanpos = token;
5072     boolean retval = !jj_3_1();
5073     jj_save(0, xla);
5074     return retval;
5075   }
5076
5077   static final private boolean jj_2_2(int xla) {
5078     jj_la = xla; jj_lastpos = jj_scanpos = token;
5079     boolean retval = !jj_3_2();
5080     jj_save(1, xla);
5081     return retval;
5082   }
5083
5084   static final private boolean jj_2_3(int xla) {
5085     jj_la = xla; jj_lastpos = jj_scanpos = token;
5086     boolean retval = !jj_3_3();
5087     jj_save(2, xla);
5088     return retval;
5089   }
5090
5091   static final private boolean jj_2_4(int xla) {
5092     jj_la = xla; jj_lastpos = jj_scanpos = token;
5093     boolean retval = !jj_3_4();
5094     jj_save(3, xla);
5095     return retval;
5096   }
5097
5098   static final private boolean jj_2_5(int xla) {
5099     jj_la = xla; jj_lastpos = jj_scanpos = token;
5100     boolean retval = !jj_3_5();
5101     jj_save(4, xla);
5102     return retval;
5103   }
5104
5105   static final private boolean jj_3R_155() {
5106     if (jj_3R_161()) return true;
5107     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5108     return false;
5109   }
5110
5111   static final private boolean jj_3R_160() {
5112     if (jj_scan_token(MINUS)) return true;
5113     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5114     return false;
5115   }
5116
5117   static final private boolean jj_3R_159() {
5118     if (jj_scan_token(PLUS)) return true;
5119     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5120     return false;
5121   }
5122
5123   static final private boolean jj_3R_152() {
5124     Token xsp;
5125     xsp = jj_scanpos;
5126     if (jj_3R_154()) {
5127     jj_scanpos = xsp;
5128     if (jj_3R_155()) {
5129     jj_scanpos = xsp;
5130     if (jj_3R_156()) return true;
5131     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5132     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5133     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5134     return false;
5135   }
5136
5137   static final private boolean jj_3R_154() {
5138     Token xsp;
5139     xsp = jj_scanpos;
5140     if (jj_3R_159()) {
5141     jj_scanpos = xsp;
5142     if (jj_3R_160()) return true;
5143     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5144     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5145     if (jj_3R_143()) return true;
5146     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5147     return false;
5148   }
5149
5150   static final private boolean jj_3R_158() {
5151     if (jj_3R_152()) return true;
5152     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5153     return false;
5154   }
5155
5156   static final private boolean jj_3R_50() {
5157     if (jj_3R_65()) return true;
5158     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5159     Token xsp;
5160     xsp = jj_scanpos;
5161     if (jj_3R_66()) jj_scanpos = xsp;
5162     else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5163     return false;
5164   }
5165
5166   static final private boolean jj_3R_153() {
5167     Token xsp;
5168     xsp = jj_scanpos;
5169     if (jj_3R_157()) {
5170     jj_scanpos = xsp;
5171     if (jj_3R_158()) return true;
5172     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5173     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5174     return false;
5175   }
5176
5177   static final private boolean jj_3R_157() {
5178     if (jj_scan_token(AT)) return true;
5179     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5180     if (jj_3R_153()) return true;
5181     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5182     return false;
5183   }
5184
5185   static final private boolean jj_3R_51() {
5186     if (jj_scan_token(COMMA)) return true;
5187     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5188     if (jj_3R_50()) return true;
5189     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5190     return false;
5191   }
5192
5193   static final private boolean jj_3R_148() {
5194     if (jj_3R_153()) return true;
5195     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5196     return false;
5197   }
5198
5199   static final private boolean jj_3R_143() {
5200     Token xsp;
5201     xsp = jj_scanpos;
5202     if (jj_3R_147()) {
5203     jj_scanpos = xsp;
5204     if (jj_3R_148()) return true;
5205     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5206     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5207     return false;
5208   }
5209
5210   static final private boolean jj_3R_147() {
5211     if (jj_scan_token(BIT_AND)) return true;
5212     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5213     if (jj_3R_152()) return true;
5214     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5215     return false;
5216   }
5217
5218   static final private boolean jj_3R_44() {
5219     if (jj_3R_50()) return true;
5220     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5221     Token xsp;
5222     while (true) {
5223       xsp = jj_scanpos;
5224       if (jj_3R_51()) { jj_scanpos = xsp; break; }
5225       if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5226     }
5227     return false;
5228   }
5229
5230   static final private boolean jj_3R_151() {
5231     if (jj_scan_token(REMAINDER)) return true;
5232     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5233     return false;
5234   }
5235
5236   static final private boolean jj_3R_150() {
5237     if (jj_scan_token(SLASH)) 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_149() {
5243     if (jj_scan_token(STAR)) return true;
5244     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5245     return false;
5246   }
5247
5248   static final private boolean jj_3R_144() {
5249     Token xsp;
5250     xsp = jj_scanpos;
5251     if (jj_3R_149()) {
5252     jj_scanpos = xsp;
5253     if (jj_3R_150()) {
5254     jj_scanpos = xsp;
5255     if (jj_3R_151()) return true;
5256     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5257     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5258     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5259     if (jj_3R_143()) return true;
5260     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5261     return false;
5262   }
5263
5264   static final private boolean jj_3R_138() {
5265     if (jj_3R_143()) return true;
5266     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5267     Token xsp;
5268     while (true) {
5269       xsp = jj_scanpos;
5270       if (jj_3R_144()) { jj_scanpos = xsp; break; }
5271       if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5272     }
5273     return false;
5274   }
5275
5276   static final private boolean jj_3R_146() {
5277     if (jj_scan_token(MINUS)) return true;
5278     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5279     return false;
5280   }
5281
5282   static final private boolean jj_3R_145() {
5283     if (jj_scan_token(PLUS)) return true;
5284     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5285     return false;
5286   }
5287
5288   static final private boolean jj_3R_139() {
5289     Token xsp;
5290     xsp = jj_scanpos;
5291     if (jj_3R_145()) {
5292     jj_scanpos = xsp;
5293     if (jj_3R_146()) return true;
5294     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5295     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5296     if (jj_3R_138()) return true;
5297     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5298     return false;
5299   }
5300
5301   static final private boolean jj_3R_132() {
5302     if (jj_3R_138()) return true;
5303     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5304     Token xsp;
5305     while (true) {
5306       xsp = jj_scanpos;
5307       if (jj_3R_139()) { jj_scanpos = xsp; break; }
5308       if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5309     }
5310     return false;
5311   }
5312
5313   static final private boolean jj_3R_142() {
5314     if (jj_scan_token(RUNSIGNEDSHIFT)) return true;
5315     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5316     return false;
5317   }
5318
5319   static final private boolean jj_3_4() {
5320     if (jj_3R_43()) return true;
5321     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5322     if (jj_scan_token(SEMICOLON)) return true;
5323     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5324     return false;
5325   }
5326
5327   static final private boolean jj_3R_141() {
5328     if (jj_scan_token(RSIGNEDSHIFT)) return true;
5329     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5330     return false;
5331   }
5332
5333   static final private boolean jj_3R_140() {
5334     if (jj_scan_token(LSHIFT)) return true;
5335     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5336     return false;
5337   }
5338
5339   static final private boolean jj_3R_133() {
5340     Token xsp;
5341     xsp = jj_scanpos;
5342     if (jj_3R_140()) {
5343     jj_scanpos = xsp;
5344     if (jj_3R_141()) {
5345     jj_scanpos = xsp;
5346     if (jj_3R_142()) return true;
5347     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5348     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5349     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5350     if (jj_3R_132()) return true;
5351     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5352     return false;
5353   }
5354
5355   static final private boolean jj_3R_124() {
5356     if (jj_3R_132()) return true;
5357     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5358     Token xsp;
5359     while (true) {
5360       xsp = jj_scanpos;
5361       if (jj_3R_133()) { jj_scanpos = xsp; break; }
5362       if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5363     }
5364     return false;
5365   }
5366
5367   static final private boolean jj_3R_137() {
5368     if (jj_scan_token(GE)) return true;
5369     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5370     return false;
5371   }
5372
5373   static final private boolean jj_3R_201() {
5374     if (jj_scan_token(COMMA)) return true;
5375     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5376     return false;
5377   }
5378
5379   static final private boolean jj_3R_136() {
5380     if (jj_scan_token(LE)) return true;
5381     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5382     return false;
5383   }
5384
5385   static final private boolean jj_3R_135() {
5386     if (jj_scan_token(GT)) return true;
5387     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5388     return false;
5389   }
5390
5391   static final private boolean jj_3R_134() {
5392     if (jj_scan_token(LT)) return true;
5393     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5394     return false;
5395   }
5396
5397   static final private boolean jj_3_2() {
5398     if (jj_scan_token(COMMA)) return true;
5399     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5400     if (jj_3R_40()) return true;
5401     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5402     return false;
5403   }
5404
5405   static final private boolean jj_3R_125() {
5406     Token xsp;
5407     xsp = jj_scanpos;
5408     if (jj_3R_134()) {
5409     jj_scanpos = xsp;
5410     if (jj_3R_135()) {
5411     jj_scanpos = xsp;
5412     if (jj_3R_136()) {
5413     jj_scanpos = xsp;
5414     if (jj_3R_137()) return true;
5415     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5416     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5417     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5418     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5419     if (jj_3R_124()) return true;
5420     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5421     return false;
5422   }
5423
5424   static final private boolean jj_3R_119() {
5425     if (jj_3R_124()) return true;
5426     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5427     Token xsp;
5428     while (true) {
5429       xsp = jj_scanpos;
5430       if (jj_3R_125()) { jj_scanpos = xsp; break; }
5431       if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5432     }
5433     return false;
5434   }
5435
5436   static final private boolean jj_3R_205() {
5437     if (jj_scan_token(COMMA)) return true;
5438     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5439     if (jj_3R_43()) return true;
5440     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5441     return false;
5442   }
5443
5444   static final private boolean jj_3R_200() {
5445     if (jj_3R_40()) return true;
5446     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5447     Token xsp;
5448     while (true) {
5449       xsp = jj_scanpos;
5450       if (jj_3_2()) { jj_scanpos = xsp; break; }
5451       if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5452     }
5453     return false;
5454   }
5455
5456   static final private boolean jj_3_5() {
5457     if (jj_3R_44()) return true;
5458     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5459     return false;
5460   }
5461
5462   static final private boolean jj_3R_203() {
5463     if (jj_3R_43()) return true;
5464     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5465     Token xsp;
5466     while (true) {
5467       xsp = jj_scanpos;
5468       if (jj_3R_205()) { jj_scanpos = xsp; break; }
5469       if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5470     }
5471     return false;
5472   }
5473
5474   static final private boolean jj_3R_192() {
5475     if (jj_scan_token(LPAREN)) return true;
5476     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5477     Token xsp;
5478     xsp = jj_scanpos;
5479     if (jj_3R_200()) jj_scanpos = xsp;
5480     else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5481     xsp = jj_scanpos;
5482     if (jj_3R_201()) jj_scanpos = xsp;
5483     else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5484     if (jj_scan_token(RPAREN)) return true;
5485     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5486     return false;
5487   }
5488
5489   static final private boolean jj_3R_204() {
5490     if (jj_scan_token(ARRAYASSIGN)) return true;
5491     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5492     if (jj_3R_43()) return true;
5493     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5494     return false;
5495   }
5496
5497   static final private boolean jj_3R_202() {
5498     if (jj_3R_203()) return true;
5499     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5500     return false;
5501   }
5502
5503   static final private boolean jj_3R_40() {
5504     if (jj_3R_43()) return true;
5505     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5506     Token xsp;
5507     xsp = jj_scanpos;
5508     if (jj_3R_204()) jj_scanpos = xsp;
5509     else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5510     return false;
5511   }
5512
5513   static final private boolean jj_3R_130() {
5514     if (jj_scan_token(TRIPLEEQUAL)) return true;
5515     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5516     return false;
5517   }
5518
5519   static final private boolean jj_3R_129() {
5520     if (jj_scan_token(BANGDOUBLEEQUAL)) return true;
5521     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5522     return false;
5523   }
5524
5525   static final private boolean jj_3R_128() {
5526     if (jj_scan_token(NOT_EQUAL)) return true;
5527     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5528     return false;
5529   }
5530
5531   static final private boolean jj_3R_127() {
5532     if (jj_scan_token(DIF)) return true;
5533     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5534     return false;
5535   }
5536
5537   static final private boolean jj_3R_72() {
5538     if (jj_3R_47()) return true;
5539     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5540     return false;
5541   }
5542
5543   static final private boolean jj_3R_126() {
5544     if (jj_scan_token(EQUAL_EQUAL)) return true;
5545     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5546     return false;
5547   }
5548
5549   static final private boolean jj_3R_196() {
5550     if (jj_scan_token(LPAREN)) return true;
5551     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5552     Token xsp;
5553     xsp = jj_scanpos;
5554     if (jj_3R_202()) jj_scanpos = xsp;
5555     else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5556     if (jj_scan_token(RPAREN)) return true;
5557     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5558     return false;
5559   }
5560
5561   static final private boolean jj_3R_120() {
5562     Token xsp;
5563     xsp = jj_scanpos;
5564     if (jj_3R_126()) {
5565     jj_scanpos = xsp;
5566     if (jj_3R_127()) {
5567     jj_scanpos = xsp;
5568     if (jj_3R_128()) {
5569     jj_scanpos = xsp;
5570     if (jj_3R_129()) {
5571     jj_scanpos = xsp;
5572     if (jj_3R_130()) return true;
5573     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5574     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5575     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5576     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5577     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5578     if (jj_3R_119()) 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_117() {
5584     if (jj_3R_119()) return true;
5585     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5586     Token xsp;
5587     while (true) {
5588       xsp = jj_scanpos;
5589       if (jj_3R_120()) { jj_scanpos = xsp; break; }
5590       if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5591     }
5592     return false;
5593   }
5594
5595   static final private boolean jj_3R_178() {
5596     if (jj_scan_token(NULL)) return true;
5597     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5598     return false;
5599   }
5600
5601   static final private boolean jj_3R_177() {
5602     if (jj_scan_token(FALSE)) return true;
5603     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5604     return false;
5605   }
5606
5607   static final private boolean jj_3R_176() {
5608     if (jj_scan_token(TRUE)) return true;
5609     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5610     return false;
5611   }
5612
5613   static final private boolean jj_3R_118() {
5614     if (jj_scan_token(BIT_AND)) return true;
5615     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5616     if (jj_3R_117()) return true;
5617     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5618     return false;
5619   }
5620
5621   static final private boolean jj_3R_175() {
5622     if (jj_scan_token(STRING_LITERAL)) return true;
5623     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5624     return false;
5625   }
5626
5627   static final private boolean jj_3R_174() {
5628     if (jj_scan_token(FLOATING_POINT_LITERAL)) return true;
5629     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5630     return false;
5631   }
5632
5633   static final private boolean jj_3R_102() {
5634     if (jj_3R_117()) return true;
5635     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5636     Token xsp;
5637     while (true) {
5638       xsp = jj_scanpos;
5639       if (jj_3R_118()) { jj_scanpos = xsp; break; }
5640       if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5641     }
5642     return false;
5643   }
5644
5645   static final private boolean jj_3R_171() {
5646     Token xsp;
5647     xsp = jj_scanpos;
5648     if (jj_3R_173()) {
5649     jj_scanpos = xsp;
5650     if (jj_3R_174()) {
5651     jj_scanpos = xsp;
5652     if (jj_3R_175()) {
5653     jj_scanpos = xsp;
5654     if (jj_3R_176()) {
5655     jj_scanpos = xsp;
5656     if (jj_3R_177()) {
5657     jj_scanpos = xsp;
5658     if (jj_3R_178()) return true;
5659     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5660     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5661     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5662     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5663     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5664     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5665     return false;
5666   }
5667
5668   static final private boolean jj_3R_173() {
5669     if (jj_scan_token(INTEGER_LITERAL)) return true;
5670     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5671     return false;
5672   }
5673
5674   static final private boolean jj_3R_71() {
5675     if (jj_3R_43()) return true;
5676     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5677     return false;
5678   }
5679
5680   static final private boolean jj_3R_53() {
5681     Token xsp;
5682     xsp = jj_scanpos;
5683     if (jj_3R_71()) {
5684     jj_scanpos = xsp;
5685     if (jj_3R_72()) return true;
5686     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5687     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5688     return false;
5689   }
5690
5691   static final private boolean jj_3R_101() {
5692     if (jj_scan_token(LBRACE)) return true;
5693     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5694     if (jj_3R_43()) return true;
5695     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5696     if (jj_scan_token(RBRACE)) return true;
5697     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5698     return false;
5699   }
5700
5701   static final private boolean jj_3R_103() {
5702     if (jj_scan_token(XOR)) return true;
5703     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5704     if (jj_3R_102()) return true;
5705     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5706     return false;
5707   }
5708
5709   static final private boolean jj_3R_70() {
5710     if (jj_scan_token(DOLLAR_ID)) return true;
5711     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5712     return false;
5713   }
5714
5715   static final private boolean jj_3R_98() {
5716     if (jj_3R_102()) return true;
5717     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5718     Token xsp;
5719     while (true) {
5720       xsp = jj_scanpos;
5721       if (jj_3R_103()) { jj_scanpos = xsp; break; }
5722       if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5723     }
5724     return false;
5725   }
5726
5727   static final private boolean jj_3R_69() {
5728     if (jj_scan_token(DOLLAR)) return true;
5729     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5730     if (jj_3R_52()) return true;
5731     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5732     return false;
5733   }
5734
5735   static final private boolean jj_3R_46() {
5736     if (jj_scan_token(LBRACKET)) return true;
5737     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5738     Token xsp;
5739     xsp = jj_scanpos;
5740     if (jj_3R_53()) jj_scanpos = xsp;
5741     else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5742     if (jj_scan_token(RBRACKET)) return true;
5743     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5744     return false;
5745   }
5746
5747   static final private boolean jj_3R_99() {
5748     if (jj_scan_token(BIT_OR)) return true;
5749     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5750     if (jj_3R_98()) return true;
5751     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5752     return false;
5753   }
5754
5755   static final private boolean jj_3R_91() {
5756     if (jj_3R_98()) return true;
5757     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5758     Token xsp;
5759     while (true) {
5760       xsp = jj_scanpos;
5761       if (jj_3R_99()) { jj_scanpos = xsp; break; }
5762       if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5763     }
5764     return false;
5765   }
5766
5767   static final private boolean jj_3R_68() {
5768     if (jj_scan_token(IDENTIFIER)) return true;
5769     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5770     Token xsp;
5771     xsp = jj_scanpos;
5772     if (jj_3R_101()) jj_scanpos = xsp;
5773     else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5774     return false;
5775   }
5776
5777   static final private boolean jj_3R_45() {
5778     if (jj_scan_token(CLASSACCESS)) return true;
5779     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5780     if (jj_3R_52()) return true;
5781     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5782     return false;
5783   }
5784
5785   static final private boolean jj_3R_39() {
5786     Token xsp;
5787     xsp = jj_scanpos;
5788     if (jj_3R_45()) {
5789     jj_scanpos = xsp;
5790     if (jj_3R_46()) return true;
5791     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5792     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5793     return false;
5794   }
5795
5796   static final private boolean jj_3R_92() {
5797     if (jj_scan_token(DOT)) return true;
5798     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5799     if (jj_3R_91()) return true;
5800     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5801     return false;
5802   }
5803
5804   static final private boolean jj_3R_52() {
5805     Token xsp;
5806     xsp = jj_scanpos;
5807     if (jj_3R_67()) {
5808     jj_scanpos = xsp;
5809     if (jj_3R_68()) {
5810     jj_scanpos = xsp;
5811     if (jj_3R_69()) {
5812     jj_scanpos = xsp;
5813     if (jj_3R_70()) return true;
5814     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5815     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5816     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5817     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5818     return false;
5819   }
5820
5821   static final private boolean jj_3R_67() {
5822     if (jj_scan_token(LBRACE)) return true;
5823     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5824     if (jj_3R_43()) return true;
5825     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5826     if (jj_scan_token(RBRACE)) return true;
5827     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5828     return false;
5829   }
5830
5831   static final private boolean jj_3R_83() {
5832     if (jj_3R_91()) return true;
5833     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5834     Token xsp;
5835     while (true) {
5836       xsp = jj_scanpos;
5837       if (jj_3R_92()) { jj_scanpos = xsp; break; }
5838       if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5839     }
5840     return false;
5841   }
5842
5843   static final private boolean jj_3R_90() {
5844     if (jj_scan_token(LBRACE)) return true;
5845     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5846     if (jj_3R_43()) return true;
5847     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5848     if (jj_scan_token(RBRACE)) return true;
5849     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5850     return false;
5851   }
5852
5853   static final private boolean jj_3R_195() {
5854     if (jj_3R_65()) return true;
5855     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5856     return false;
5857   }
5858
5859   static final private boolean jj_3R_194() {
5860     if (jj_3R_47()) return true;
5861     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5862     return false;
5863   }
5864
5865   static final private boolean jj_3R_94() {
5866     if (jj_scan_token(_ANDL)) return true;
5867     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5868     return false;
5869   }
5870
5871   static final private boolean jj_3R_93() {
5872     if (jj_scan_token(AND_AND)) return true;
5873     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5874     return false;
5875   }
5876
5877   static final private boolean jj_3R_193() {
5878     if (jj_scan_token(IDENTIFIER)) return true;
5879     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5880     return false;
5881   }
5882
5883   static final private boolean jj_3R_189() {
5884     Token xsp;
5885     xsp = jj_scanpos;
5886     if (jj_3R_193()) {
5887     jj_scanpos = xsp;
5888     if (jj_3R_194()) {
5889     jj_scanpos = xsp;
5890     if (jj_3R_195()) return true;
5891     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5892     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5893     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5894     return false;
5895   }
5896
5897   static final private boolean jj_3R_84() {
5898     Token xsp;
5899     xsp = jj_scanpos;
5900     if (jj_3R_93()) {
5901     jj_scanpos = xsp;
5902     if (jj_3R_94()) return true;
5903     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5904     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5905     if (jj_3R_83()) return true;
5906     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5907     return false;
5908   }
5909
5910   static final private boolean jj_3R_78() {
5911     if (jj_3R_83()) return true;
5912     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5913     Token xsp;
5914     while (true) {
5915       xsp = jj_scanpos;
5916       if (jj_3R_84()) { jj_scanpos = xsp; break; }
5917       if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5918     }
5919     return false;
5920   }
5921
5922   static final private boolean jj_3R_74() {
5923     if (jj_scan_token(HOOK)) return true;
5924     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5925     if (jj_3R_43()) return true;
5926     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5927     if (jj_scan_token(COLON)) return true;
5928     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5929     if (jj_3R_63()) return true;
5930     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5931     return false;
5932   }
5933
5934   static final private boolean jj_3R_82() {
5935     if (jj_scan_token(DOLLAR)) return true;
5936     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5937     if (jj_3R_52()) return true;
5938     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5939     return false;
5940   }
5941
5942   static final private boolean jj_3R_86() {
5943     if (jj_scan_token(_ORL)) return true;
5944     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5945     return false;
5946   }
5947
5948   static final private boolean jj_3R_85() {
5949     if (jj_scan_token(OR_OR)) return true;
5950     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5951     return false;
5952   }
5953
5954   static final private boolean jj_3R_123() {
5955     if (jj_scan_token(ASSIGN)) return true;
5956     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5957     if (jj_3R_43()) return true;
5958     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5959     return false;
5960   }
5961
5962   static final private boolean jj_3R_81() {
5963     if (jj_scan_token(DOLLAR_ID)) return true;
5964     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5965     Token xsp;
5966     xsp = jj_scanpos;
5967     if (jj_3R_90()) jj_scanpos = xsp;
5968     else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5969     return false;
5970   }
5971
5972   static final private boolean jj_3R_77() {
5973     Token xsp;
5974     xsp = jj_scanpos;
5975     if (jj_3R_81()) {
5976     jj_scanpos = xsp;
5977     if (jj_3R_82()) return true;
5978     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5979     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5980     return false;
5981   }
5982
5983   static final private boolean jj_3R_79() {
5984     Token xsp;
5985     xsp = jj_scanpos;
5986     if (jj_3R_85()) {
5987     jj_scanpos = xsp;
5988     if (jj_3R_86()) return true;
5989     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5990     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5991     if (jj_3R_78()) return true;
5992     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5993     return false;
5994   }
5995
5996   static final private boolean jj_3R_73() {
5997     if (jj_3R_78()) return true;
5998     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5999     Token xsp;
6000     while (true) {
6001       xsp = jj_scanpos;
6002       if (jj_3R_79()) { jj_scanpos = xsp; break; }
6003       if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6004     }
6005     return false;
6006   }
6007
6008   static final private boolean jj_3R_131() {
6009     if (jj_3R_65()) return true;
6010     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6011     return false;
6012   }
6013
6014   static final private boolean jj_3R_182() {
6015     if (jj_scan_token(ARRAY)) return true;
6016     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6017     if (jj_3R_192()) return true;
6018     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6019     return false;
6020   }
6021
6022   static final private boolean jj_3R_122() {
6023     if (jj_scan_token(COMMA)) return true;
6024     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6025     Token xsp;
6026     xsp = jj_scanpos;
6027     if (jj_3R_131()) jj_scanpos = xsp;
6028     else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6029     return false;
6030   }
6031
6032   static final private boolean jj_3R_63() {
6033     if (jj_3R_73()) return true;
6034     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6035     Token xsp;
6036     xsp = jj_scanpos;
6037     if (jj_3R_74()) jj_scanpos = xsp;
6038     else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6039     return false;
6040   }
6041
6042   static final private boolean jj_3R_121() {
6043     if (jj_3R_65()) return true;
6044     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6045     return false;
6046   }
6047
6048   static final private boolean jj_3_1() {
6049     if (jj_3R_39()) return true;
6050     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6051     return false;
6052   }
6053
6054   static final private boolean jj_3R_116() {
6055     if (jj_scan_token(TILDEEQUAL)) return true;
6056     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6057     return false;
6058   }
6059
6060   static final private boolean jj_3R_115() {
6061     if (jj_scan_token(DOTASSIGN)) return true;
6062     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6063     return false;
6064   }
6065
6066   static final private boolean jj_3R_114() {
6067     if (jj_scan_token(ORASSIGN)) return true;
6068     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6069     return false;
6070   }
6071
6072   static final private boolean jj_3R_199() {
6073     if (jj_scan_token(STATICCLASSACCESS)) return true;
6074     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6075     if (jj_3R_189()) return true;
6076     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6077     return false;
6078   }
6079
6080   static final private boolean jj_3R_113() {
6081     if (jj_scan_token(XORASSIGN)) return true;
6082     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6083     return false;
6084   }
6085
6086   static final private boolean jj_3R_198() {
6087     if (jj_3R_39()) return true;
6088     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6089     return false;
6090   }
6091
6092   static final private boolean jj_3R_65() {
6093     if (jj_3R_77()) return true;
6094     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6095     Token xsp;
6096     while (true) {
6097       xsp = jj_scanpos;
6098       if (jj_3_1()) { jj_scanpos = xsp; break; }
6099       if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6100     }
6101     return false;
6102   }
6103
6104   static final private boolean jj_3R_112() {
6105     if (jj_scan_token(ANDASSIGN)) return true;
6106     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6107     return false;
6108   }
6109
6110   static final private boolean jj_3R_197() {
6111     if (jj_3R_196()) return true;
6112     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6113     return false;
6114   }
6115
6116   static final private boolean jj_3R_191() {
6117     Token xsp;
6118     xsp = jj_scanpos;
6119     if (jj_3R_197()) {
6120     jj_scanpos = xsp;
6121     if (jj_3R_198()) {
6122     jj_scanpos = xsp;
6123     if (jj_3R_199()) return true;
6124     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6125     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6126     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6127     return false;
6128   }
6129
6130   static final private boolean jj_3R_111() {
6131     if (jj_scan_token(RSIGNEDSHIFTASSIGN)) 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_96() {
6137     if (jj_scan_token(LIST)) return true;
6138     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6139     if (jj_scan_token(LPAREN)) return true;
6140     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6141     Token xsp;
6142     xsp = jj_scanpos;
6143     if (jj_3R_121()) jj_scanpos = xsp;
6144     else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6145     while (true) {
6146       xsp = jj_scanpos;
6147       if (jj_3R_122()) { jj_scanpos = xsp; break; }
6148       if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6149     }
6150     if (jj_scan_token(RPAREN)) return true;
6151     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6152     xsp = jj_scanpos;
6153     if (jj_3R_123()) jj_scanpos = xsp;
6154     else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6155     return false;
6156   }
6157
6158   static final private boolean jj_3R_110() {
6159     if (jj_scan_token(LSHIFTASSIGN)) return true;
6160     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6161     return false;
6162   }
6163
6164   static final private boolean jj_3R_109() {
6165     if (jj_scan_token(MINUSASSIGN)) return true;
6166     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6167     return false;
6168   }
6169
6170   static final private boolean jj_3R_108() {
6171     if (jj_scan_token(PLUSASSIGN)) return true;
6172     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6173     return false;
6174   }
6175
6176   static final private boolean jj_3R_107() {
6177     if (jj_scan_token(REMASSIGN)) return true;
6178     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6179     return false;
6180   }
6181
6182   static final private boolean jj_3R_106() {
6183     if (jj_scan_token(SLASHASSIGN)) return true;
6184     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6185     return false;
6186   }
6187
6188   static final private boolean jj_3R_105() {
6189     if (jj_scan_token(STARASSIGN)) return true;
6190     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6191     return false;
6192   }
6193
6194   static final private boolean jj_3R_104() {
6195     if (jj_scan_token(ASSIGN)) return true;
6196     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6197     return false;
6198   }
6199
6200   static final private boolean jj_3R_100() {
6201     Token xsp;
6202     xsp = jj_scanpos;
6203     if (jj_3R_104()) {
6204     jj_scanpos = xsp;
6205     if (jj_3R_105()) {
6206     jj_scanpos = xsp;
6207     if (jj_3R_106()) {
6208     jj_scanpos = xsp;
6209     if (jj_3R_107()) {
6210     jj_scanpos = xsp;
6211     if (jj_3R_108()) {
6212     jj_scanpos = xsp;
6213     if (jj_3R_109()) {
6214     jj_scanpos = xsp;
6215     if (jj_3R_110()) {
6216     jj_scanpos = xsp;
6217     if (jj_3R_111()) {
6218     jj_scanpos = xsp;
6219     if (jj_3R_112()) {
6220     jj_scanpos = xsp;
6221     if (jj_3R_113()) {
6222     jj_scanpos = xsp;
6223     if (jj_3R_114()) {
6224     jj_scanpos = xsp;
6225     if (jj_3R_115()) {
6226     jj_scanpos = xsp;
6227     if (jj_3R_116()) return true;
6228     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6229     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6230     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6231     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6232     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6233     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6234     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6235     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6236     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6237     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6238     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6239     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6240     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6241     return false;
6242   }
6243
6244   static final private boolean jj_3R_190() {
6245     if (jj_3R_196()) return true;
6246     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6247     return false;
6248   }
6249
6250   static final private boolean jj_3R_95() {
6251     if (jj_scan_token(PRINT)) return true;
6252     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6253     if (jj_3R_43()) return true;
6254     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6255     return false;
6256   }
6257
6258   static final private boolean jj_3R_181() {
6259     if (jj_scan_token(NEW)) return true;
6260     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6261     if (jj_3R_189()) return true;
6262     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6263     Token xsp;
6264     xsp = jj_scanpos;
6265     if (jj_3R_190()) jj_scanpos = xsp;
6266     else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6267     return false;
6268   }
6269
6270   static final private boolean jj_3R_180() {
6271     if (jj_3R_182()) return true;
6272     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6273     return false;
6274   }
6275
6276   static final private boolean jj_3R_188() {
6277     if (jj_3R_191()) return true;
6278     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6279     return false;
6280   }
6281
6282   static final private boolean jj_3R_179() {
6283     if (jj_scan_token(IDENTIFIER)) return true;
6284     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6285     Token xsp;
6286     while (true) {
6287       xsp = jj_scanpos;
6288       if (jj_3R_188()) { jj_scanpos = xsp; break; }
6289       if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6290     }
6291     return false;
6292   }
6293
6294   static final private boolean jj_3R_172() {
6295     Token xsp;
6296     xsp = jj_scanpos;
6297     if (jj_3R_179()) {
6298     jj_scanpos = xsp;
6299     if (jj_3R_180()) {
6300     jj_scanpos = xsp;
6301     if (jj_3R_181()) return true;
6302     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6303     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6304     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6305     return false;
6306   }
6307
6308   static final private boolean jj_3R_187() {
6309     if (jj_scan_token(MINUS_MINUS)) return true;
6310     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6311     return false;
6312   }
6313
6314   static final private boolean jj_3R_186() {
6315     if (jj_scan_token(PLUS_PLUS)) return true;
6316     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6317     return false;
6318   }
6319
6320   static final private boolean jj_3R_185() {
6321     Token xsp;
6322     xsp = jj_scanpos;
6323     if (jj_3R_186()) {
6324     jj_scanpos = xsp;
6325     if (jj_3R_187()) return true;
6326     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6327     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6328     return false;
6329   }
6330
6331   static final private boolean jj_3R_97() {
6332     if (jj_3R_100()) return true;
6333     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6334     if (jj_3R_43()) return true;
6335     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6336     return false;
6337   }
6338
6339   static final private boolean jj_3R_89() {
6340     if (jj_3R_65()) return true;
6341     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6342     Token xsp;
6343     xsp = jj_scanpos;
6344     if (jj_3R_97()) jj_scanpos = xsp;
6345     else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6346     return false;
6347   }
6348
6349   static final private boolean jj_3R_170() {
6350     if (jj_3R_172()) return true;
6351     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6352     Token xsp;
6353     xsp = jj_scanpos;
6354     if (jj_3R_185()) jj_scanpos = xsp;
6355     else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6356     return false;
6357   }
6358
6359   static final private boolean jj_3R_88() {
6360     if (jj_3R_96()) return true;
6361     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6362     return false;
6363   }
6364
6365   static final private boolean jj_3R_87() {
6366     if (jj_3R_95()) return true;
6367     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6368     return false;
6369   }
6370
6371   static final private boolean jj_3R_80() {
6372     Token xsp;
6373     xsp = jj_scanpos;
6374     if (jj_3R_87()) {
6375     jj_scanpos = xsp;
6376     if (jj_3R_88()) {
6377     jj_scanpos = xsp;
6378     if (jj_3R_89()) return true;
6379     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6380     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6381     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6382     return false;
6383   }
6384
6385   static final private boolean jj_3R_184() {
6386     if (jj_scan_token(ARRAY)) return true;
6387     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6388     return false;
6389   }
6390
6391   static final private boolean jj_3R_183() {
6392     if (jj_3R_47()) return true;
6393     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6394     return false;
6395   }
6396
6397   static final private boolean jj_3R_42() {
6398     if (jj_scan_token(ARRAY)) return true;
6399     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6400     return false;
6401   }
6402
6403   static final private boolean jj_3R_76() {
6404     if (jj_3R_80()) return true;
6405     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6406     return false;
6407   }
6408
6409   static final private boolean jj_3R_75() {
6410     if (jj_scan_token(BANG)) return true;
6411     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6412     if (jj_3R_64()) return true;
6413     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6414     return false;
6415   }
6416
6417   static final private boolean jj_3R_64() {
6418     Token xsp;
6419     xsp = jj_scanpos;
6420     if (jj_3R_75()) {
6421     jj_scanpos = xsp;
6422     if (jj_3R_76()) return true;
6423     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6424     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6425     return false;
6426   }
6427
6428   static final private boolean jj_3R_169() {
6429     if (jj_scan_token(LPAREN)) return true;
6430     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6431     Token xsp;
6432     xsp = jj_scanpos;
6433     if (jj_3R_183()) {
6434     jj_scanpos = xsp;
6435     if (jj_3R_184()) 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     if (jj_scan_token(RPAREN)) return true;
6439     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6440     if (jj_3R_143()) return true;
6441     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6442     return false;
6443   }
6444
6445   static final private boolean jj_3R_41() {
6446     if (jj_3R_47()) return true;
6447     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6448     return false;
6449   }
6450
6451   static final private boolean jj_3R_49() {
6452     if (jj_3R_64()) return true;
6453     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6454     return false;
6455   }
6456
6457   static final private boolean jj_3R_48() {
6458     if (jj_3R_63()) return true;
6459     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6460     return false;
6461   }
6462
6463   static final private boolean jj_3R_43() {
6464     Token xsp;
6465     xsp = jj_scanpos;
6466     if (jj_3R_48()) {
6467     jj_scanpos = xsp;
6468     if (jj_3R_49()) return true;
6469     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6470     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6471     return false;
6472   }
6473
6474   static final private boolean jj_3_3() {
6475     if (jj_scan_token(LPAREN)) return true;
6476     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6477     Token xsp;
6478     xsp = jj_scanpos;
6479     if (jj_3R_41()) {
6480     jj_scanpos = xsp;
6481     if (jj_3R_42()) return true;
6482     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6483     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6484     if (jj_scan_token(RPAREN)) return true;
6485     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6486     return false;
6487   }
6488
6489   static final private boolean jj_3R_62() {
6490     if (jj_scan_token(OBJECT)) return true;
6491     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6492     return false;
6493   }
6494
6495   static final private boolean jj_3R_168() {
6496     if (jj_scan_token(LPAREN)) return true;
6497     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6498     if (jj_3R_43()) return true;
6499     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6500     if (jj_scan_token(RPAREN)) return true;
6501     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6502     return false;
6503   }
6504
6505   static final private boolean jj_3R_61() {
6506     if (jj_scan_token(INTEGER)) return true;
6507     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6508     return false;
6509   }
6510
6511   static final private boolean jj_3R_167() {
6512     if (jj_3R_171()) return true;
6513     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6514     return false;
6515   }
6516
6517   static final private boolean jj_3R_166() {
6518     if (jj_3R_170()) return true;
6519     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6520     return false;
6521   }
6522
6523   static final private boolean jj_3R_60() {
6524     if (jj_scan_token(INT)) 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_162() {
6530     Token xsp;
6531     xsp = jj_scanpos;
6532     if (jj_3R_165()) {
6533     jj_scanpos = xsp;
6534     if (jj_3R_166()) {
6535     jj_scanpos = xsp;
6536     if (jj_3R_167()) {
6537     jj_scanpos = xsp;
6538     if (jj_3R_168()) return true;
6539     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6540     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6541     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6542     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6543     return false;
6544   }
6545
6546   static final private boolean jj_3R_165() {
6547     if (jj_3R_169()) return true;
6548     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6549     return false;
6550   }
6551
6552   static final private boolean jj_3R_59() {
6553     if (jj_scan_token(FLOAT)) return true;
6554     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6555     return false;
6556   }
6557
6558   static final private boolean jj_3R_58() {
6559     if (jj_scan_token(DOUBLE)) return true;
6560     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6561     return false;
6562   }
6563
6564   static final private boolean jj_3R_57() {
6565     if (jj_scan_token(REAL)) return true;
6566     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6567     return false;
6568   }
6569
6570   static final private boolean jj_3R_56() {
6571     if (jj_scan_token(BOOLEAN)) return true;
6572     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6573     return false;
6574   }
6575
6576   static final private boolean jj_3R_164() {
6577     if (jj_scan_token(MINUS_MINUS)) return true;
6578     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6579     return false;
6580   }
6581
6582   static final private boolean jj_3R_55() {
6583     if (jj_scan_token(BOOL)) return true;
6584     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6585     return false;
6586   }
6587
6588   static final private boolean jj_3R_163() {
6589     if (jj_scan_token(PLUS_PLUS)) return true;
6590     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6591     return false;
6592   }
6593
6594   static final private boolean jj_3R_47() {
6595     Token xsp;
6596     xsp = jj_scanpos;
6597     if (jj_3R_54()) {
6598     jj_scanpos = xsp;
6599     if (jj_3R_55()) {
6600     jj_scanpos = xsp;
6601     if (jj_3R_56()) {
6602     jj_scanpos = xsp;
6603     if (jj_3R_57()) {
6604     jj_scanpos = xsp;
6605     if (jj_3R_58()) {
6606     jj_scanpos = xsp;
6607     if (jj_3R_59()) {
6608     jj_scanpos = xsp;
6609     if (jj_3R_60()) {
6610     jj_scanpos = xsp;
6611     if (jj_3R_61()) {
6612     jj_scanpos = xsp;
6613     if (jj_3R_62()) return true;
6614     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6615     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6616     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6617     } else 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     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6622     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6623     return false;
6624   }
6625
6626   static final private boolean jj_3R_54() {
6627     if (jj_scan_token(STRING)) return true;
6628     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6629     return false;
6630   }
6631
6632   static final private boolean jj_3R_161() {
6633     Token xsp;
6634     xsp = jj_scanpos;
6635     if (jj_3R_163()) {
6636     jj_scanpos = xsp;
6637     if (jj_3R_164()) return true;
6638     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6639     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6640     if (jj_3R_172()) return true;
6641     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6642     return false;
6643   }
6644
6645   static final private boolean jj_3R_66() {
6646     if (jj_scan_token(ASSIGN)) return true;
6647     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6648     if (jj_3R_43()) return true;
6649     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6650     return false;
6651   }
6652
6653   static final private boolean jj_3R_156() {
6654     if (jj_3R_162()) return true;
6655     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6656     return false;
6657   }
6658
6659   static private boolean jj_initialized_once = false;
6660   static public PHPParserTokenManager token_source;
6661   static SimpleCharStream jj_input_stream;
6662   static public Token token, jj_nt;
6663   static private int jj_ntk;
6664   static private Token jj_scanpos, jj_lastpos;
6665   static private int jj_la;
6666   static public boolean lookingAhead = false;
6667   static private boolean jj_semLA;
6668   static private int jj_gen;
6669   static final private int[] jj_la1 = new int[125];
6670   static private int[] jj_la1_0;
6671   static private int[] jj_la1_1;
6672   static private int[] jj_la1_2;
6673   static private int[] jj_la1_3;
6674   static private int[] jj_la1_4;
6675   static {
6676       jj_la1_0();
6677       jj_la1_1();
6678       jj_la1_2();
6679       jj_la1_3();
6680       jj_la1_4();
6681    }
6682    private static void jj_la1_0() {
6683       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,0x68000000,0x60000000,0x0,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,0x8000000,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,};
6684    }
6685    private static void jj_la1_1() {
6686       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,0x30c0000,0x0,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,0x40000,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,};
6687    }
6688    private static void jj_la1_2() {
6689       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,0x13c1c00,0x1800,0x0,0x800,0x0,0x4000,0x80010000,0x80010000,0x20000,0x20000,0x0,0x2000000,0x4000000,0x1000000,0x0,0x0,0x0,0x0,0x70000000,0x70000000,0x300000,0x300000,0x8c00000,0x8c00000,0x13c0400,0x3c0400,0x300000,0x3c0000,0xc0000,0x0,0x3fe,0xc0000,0xc0000,0x0,0x0,0x0,0x0,0x0,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,0xc0000,0x8000,0x0,0x0,0x13c1c00,0x13c1c00,0x0,0x0,0x13c1c00,0x13c1c00,0x13c1c00,0x0,0x0,0x13c1c00,0x0,0x0,0x13c9c00,0x13c1c00,0x13c1c00,0x13c1c00,0x13c1c00,0x13c1c00,0x13c9c00,0xc0800,0x13c1c00,0xc0000,0x13c1c00,0x13c9c00,0xc0000,0x0,0x13c1c00,0x13c1c00,};
6690    }
6691    private static void jj_la1_3() {
6692       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,0x88a2,0x0,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,0x88000,0x8000,0x800,0x88000,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,};
6693    }
6694    private static void jj_la1_4() {
6695       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,0x4000,0x4000,0x3ffe,0x4000,0x3ffe,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,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,0x0,0x0,0x0,0x0,0x4000,0x4000,0x0,0x0,0x4000,0x4000,0x4000,0x0,0x0,0x4000,0x0,0x0,0x4000,0x4000,0x4000,0x4000,0x4000,0x4000,0x4000,0x4000,0x4000,0x0,0x4000,0x4000,0x0,0x0,0x4000,0x4000,};
6696    }
6697   static final private JJCalls[] jj_2_rtns = new JJCalls[5];
6698   static private boolean jj_rescan = false;
6699   static private int jj_gc = 0;
6700
6701   public PHPParser(java.io.InputStream stream) {
6702     if (jj_initialized_once) {
6703       System.out.println("ERROR: Second call to constructor of static parser.  You must");
6704       System.out.println("       either use ReInit() or set the JavaCC option STATIC to false");
6705       System.out.println("       during parser generation.");
6706       throw new Error();
6707     }
6708     jj_initialized_once = true;
6709     jj_input_stream = new SimpleCharStream(stream, 1, 1);
6710     token_source = new PHPParserTokenManager(jj_input_stream);
6711     token = new Token();
6712     jj_ntk = -1;
6713     jj_gen = 0;
6714     for (int i = 0; i < 125; i++) jj_la1[i] = -1;
6715     for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
6716   }
6717
6718   static public void ReInit(java.io.InputStream stream) {
6719     jj_input_stream.ReInit(stream, 1, 1);
6720     token_source.ReInit(jj_input_stream);
6721     token = new Token();
6722     jj_ntk = -1;
6723     jj_gen = 0;
6724     for (int i = 0; i < 125; i++) jj_la1[i] = -1;
6725     for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
6726   }
6727
6728   public PHPParser(java.io.Reader stream) {
6729     if (jj_initialized_once) {
6730       System.out.println("ERROR: Second call to constructor of static parser.  You must");
6731       System.out.println("       either use ReInit() or set the JavaCC option STATIC to false");
6732       System.out.println("       during parser generation.");
6733       throw new Error();
6734     }
6735     jj_initialized_once = true;
6736     jj_input_stream = new SimpleCharStream(stream, 1, 1);
6737     token_source = new PHPParserTokenManager(jj_input_stream);
6738     token = new Token();
6739     jj_ntk = -1;
6740     jj_gen = 0;
6741     for (int i = 0; i < 125; i++) jj_la1[i] = -1;
6742     for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
6743   }
6744
6745   static public void ReInit(java.io.Reader stream) {
6746     jj_input_stream.ReInit(stream, 1, 1);
6747     token_source.ReInit(jj_input_stream);
6748     token = new Token();
6749     jj_ntk = -1;
6750     jj_gen = 0;
6751     for (int i = 0; i < 125; i++) jj_la1[i] = -1;
6752     for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
6753   }
6754
6755   public PHPParser(PHPParserTokenManager tm) {
6756     if (jj_initialized_once) {
6757       System.out.println("ERROR: Second call to constructor of static parser.  You must");
6758       System.out.println("       either use ReInit() or set the JavaCC option STATIC to false");
6759       System.out.println("       during parser generation.");
6760       throw new Error();
6761     }
6762     jj_initialized_once = true;
6763     token_source = tm;
6764     token = new Token();
6765     jj_ntk = -1;
6766     jj_gen = 0;
6767     for (int i = 0; i < 125; i++) jj_la1[i] = -1;
6768     for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
6769   }
6770
6771   public void ReInit(PHPParserTokenManager tm) {
6772     token_source = tm;
6773     token = new Token();
6774     jj_ntk = -1;
6775     jj_gen = 0;
6776     for (int i = 0; i < 125; i++) jj_la1[i] = -1;
6777     for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
6778   }
6779
6780   static final private Token jj_consume_token(int kind) throws ParseException {
6781     Token oldToken;
6782     if ((oldToken = token).next != null) token = token.next;
6783     else token = token.next = token_source.getNextToken();
6784     jj_ntk = -1;
6785     if (token.kind == kind) {
6786       jj_gen++;
6787       if (++jj_gc > 100) {
6788         jj_gc = 0;
6789         for (int i = 0; i < jj_2_rtns.length; i++) {
6790           JJCalls c = jj_2_rtns[i];
6791           while (c != null) {
6792             if (c.gen < jj_gen) c.first = null;
6793             c = c.next;
6794           }
6795         }
6796       }
6797       return token;
6798     }
6799     token = oldToken;
6800     jj_kind = kind;
6801     throw generateParseException();
6802   }
6803
6804   static final private boolean jj_scan_token(int kind) {
6805     if (jj_scanpos == jj_lastpos) {
6806       jj_la--;
6807       if (jj_scanpos.next == null) {
6808         jj_lastpos = jj_scanpos = jj_scanpos.next = token_source.getNextToken();
6809       } else {
6810         jj_lastpos = jj_scanpos = jj_scanpos.next;
6811       }
6812     } else {
6813       jj_scanpos = jj_scanpos.next;
6814     }
6815     if (jj_rescan) {
6816       int i = 0; Token tok = token;
6817       while (tok != null && tok != jj_scanpos) { i++; tok = tok.next; }
6818       if (tok != null) jj_add_error_token(kind, i);
6819     }
6820     return (jj_scanpos.kind != kind);
6821   }
6822
6823   static final public Token getNextToken() {
6824     if (token.next != null) token = token.next;
6825     else token = token.next = token_source.getNextToken();
6826     jj_ntk = -1;
6827     jj_gen++;
6828     return token;
6829   }
6830
6831   static final public Token getToken(int index) {
6832     Token t = lookingAhead ? jj_scanpos : token;
6833     for (int i = 0; i < index; i++) {
6834       if (t.next != null) t = t.next;
6835       else t = t.next = token_source.getNextToken();
6836     }
6837     return t;
6838   }
6839
6840   static final private int jj_ntk() {
6841     if ((jj_nt=token.next) == null)
6842       return (jj_ntk = (token.next=token_source.getNextToken()).kind);
6843     else
6844       return (jj_ntk = jj_nt.kind);
6845   }
6846
6847   static private java.util.Vector jj_expentries = new java.util.Vector();
6848   static private int[] jj_expentry;
6849   static private int jj_kind = -1;
6850   static private int[] jj_lasttokens = new int[100];
6851   static private int jj_endpos;
6852
6853   static private void jj_add_error_token(int kind, int pos) {
6854     if (pos >= 100) return;
6855     if (pos == jj_endpos + 1) {
6856       jj_lasttokens[jj_endpos++] = kind;
6857     } else if (jj_endpos != 0) {
6858       jj_expentry = new int[jj_endpos];
6859       for (int i = 0; i < jj_endpos; i++) {
6860         jj_expentry[i] = jj_lasttokens[i];
6861       }
6862       boolean exists = false;
6863       for (java.util.Enumeration enum = jj_expentries.elements(); enum.hasMoreElements();) {
6864         int[] oldentry = (int[])(enum.nextElement());
6865         if (oldentry.length == jj_expentry.length) {
6866           exists = true;
6867           for (int i = 0; i < jj_expentry.length; i++) {
6868             if (oldentry[i] != jj_expentry[i]) {
6869               exists = false;
6870               break;
6871             }
6872           }
6873           if (exists) break;
6874         }
6875       }
6876       if (!exists) jj_expentries.addElement(jj_expentry);
6877       if (pos != 0) jj_lasttokens[(jj_endpos = pos) - 1] = kind;
6878     }
6879   }
6880
6881   static public ParseException generateParseException() {
6882     jj_expentries.removeAllElements();
6883     boolean[] la1tokens = new boolean[143];
6884     for (int i = 0; i < 143; i++) {
6885       la1tokens[i] = false;
6886     }
6887     if (jj_kind >= 0) {
6888       la1tokens[jj_kind] = true;
6889       jj_kind = -1;
6890     }
6891     for (int i = 0; i < 125; i++) {
6892       if (jj_la1[i] == jj_gen) {
6893         for (int j = 0; j < 32; j++) {
6894           if ((jj_la1_0[i] & (1<<j)) != 0) {
6895             la1tokens[j] = true;
6896           }
6897           if ((jj_la1_1[i] & (1<<j)) != 0) {
6898             la1tokens[32+j] = true;
6899           }
6900           if ((jj_la1_2[i] & (1<<j)) != 0) {
6901             la1tokens[64+j] = true;
6902           }
6903           if ((jj_la1_3[i] & (1<<j)) != 0) {
6904             la1tokens[96+j] = true;
6905           }
6906           if ((jj_la1_4[i] & (1<<j)) != 0) {
6907             la1tokens[128+j] = true;
6908           }
6909         }
6910       }
6911     }
6912     for (int i = 0; i < 143; i++) {
6913       if (la1tokens[i]) {
6914         jj_expentry = new int[1];
6915         jj_expentry[0] = i;
6916         jj_expentries.addElement(jj_expentry);
6917       }
6918     }
6919     jj_endpos = 0;
6920     jj_rescan_token();
6921     jj_add_error_token(0, 0);
6922     int[][] exptokseq = new int[jj_expentries.size()][];
6923     for (int i = 0; i < jj_expentries.size(); i++) {
6924       exptokseq[i] = (int[])jj_expentries.elementAt(i);
6925     }
6926     return new ParseException(token, exptokseq, tokenImage);
6927   }
6928
6929   static final public void enable_tracing() {
6930   }
6931
6932   static final public void disable_tracing() {
6933   }
6934
6935   static final private void jj_rescan_token() {
6936     jj_rescan = true;
6937     for (int i = 0; i < 5; i++) {
6938       JJCalls p = jj_2_rtns[i];
6939       do {
6940         if (p.gen > jj_gen) {
6941           jj_la = p.arg; jj_lastpos = jj_scanpos = p.first;
6942           switch (i) {
6943             case 0: jj_3_1(); break;
6944             case 1: jj_3_2(); break;
6945             case 2: jj_3_3(); break;
6946             case 3: jj_3_4(); break;
6947             case 4: jj_3_5(); break;
6948           }
6949         }
6950         p = p.next;
6951       } while (p != null);
6952     }
6953     jj_rescan = false;
6954   }
6955
6956   static final private void jj_save(int index, int xla) {
6957     JJCalls p = jj_2_rtns[index];
6958     while (p.gen > jj_gen) {
6959       if (p.next == null) { p = p.next = new JJCalls(); break; }
6960       p = p.next;
6961     }
6962     p.gen = jj_gen + xla - jj_la; p.first = token; p.arg = xla;
6963   }
6964
6965   static final class JJCalls {
6966     int gen;
6967     Token first;
6968     int arg;
6969     JJCalls next;
6970   }
6971
6972 }