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