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