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