net.sourceforge.phpeclipse/src/test/PHPParser.java

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