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

   1 options {
   2   LOOKAHEAD = 1;
   3   CHOICE_AMBIGUITY_CHECK = 2;
   4   OTHER_AMBIGUITY_CHECK = 1;
   5   STATIC = true;
   6   DEBUG_PARSER = false;
   7   DEBUG_LOOKAHEAD = false;
   8   DEBUG_TOKEN_MANAGER = false;
   9   OPTIMIZE_TOKEN_MANAGER = false;
  10   ERROR_REPORTING = true;
  11   JAVA_UNICODE_ESCAPE = false;
  12   UNICODE_INPUT = false;
  13   IGNORE_CASE = true;
  14   USER_TOKEN_MANAGER = false;
  15   USER_CHAR_STREAM = false;
  16   BUILD_PARSER = true;
  17   BUILD_TOKEN_MANAGER = true;
  18   SANITY_CHECK = true;
  19   FORCE_LA_CHECK = false;
  20 }
  21
  22 PARSER_BEGIN(PHPParser)
  23 package test;
  24
  25 import org.eclipse.core.resources.IFile;
  26 import org.eclipse.core.resources.IMarker;
  27 import org.eclipse.core.runtime.CoreException;
  28 import org.eclipse.ui.texteditor.MarkerUtilities;
  29 import org.eclipse.jface.preference.IPreferenceStore;
  30
  31 import java.util.Hashtable;
  32 import java.util.ArrayList;
  33 import java.io.StringReader;
  34 import java.io.*;
  35 import java.text.MessageFormat;
  36
  37 import net.sourceforge.phpeclipse.actions.PHPStartApacheAction;
  38 import net.sourceforge.phpeclipse.PHPeclipsePlugin;
  39 import net.sourceforge.phpdt.internal.compiler.ast.*;
  40 import net.sourceforge.phpdt.internal.compiler.parser.OutlineableWithChildren;
  41 import net.sourceforge.phpdt.internal.compiler.parser.Outlineable;
  42 import net.sourceforge.phpdt.internal.compiler.parser.PHPOutlineInfo;
  43
  44 /**
  45  * A new php parser.
  46  * This php parser is inspired by the Java 1.2 grammar example
  47  * given with JavaCC. You can get JavaCC at http://www.webgain.com
  48  * You can test the parser with the PHPParserTestCase2.java
  49  * @author Matthieu Casanova
  50  */
  51 public final class PHPParser extends PHPParserSuperclass {
  52
  53   /** The file that is parsed. */
  54   private static IFile fileToParse;
  55
  56   /** The current segment. */
  57   private static OutlineableWithChildren currentSegment;
  58
  59   private static final String PARSE_ERROR_STRING = "Parse error"; //$NON-NLS-1$
  60   private static final String PARSE_WARNING_STRING = "Warning"; //$NON-NLS-1$
  61   static PHPOutlineInfo outlineInfo;
  62
  63   /** The error level of the current ParseException. */
  64   private static int errorLevel = ERROR;
  65   /** The message of the current ParseException. If it's null it's because the parse exception wasn't handled */
  66   private static String errorMessage;
  67
  68   private static int errorStart = -1;
  69   private static int errorEnd = -1;
  70   private static PHPDocument phpDocument;
  71
  72   private static final char[] SYNTAX_ERROR_CHAR = {'s','y','n','t','a','x',' ','e','r','r','o','r'};
  73   /**
  74    * The point where html starts.
  75    * It will be used by the token manager to create HTMLCode objects
  76    */
  77   public static int htmlStart;
  78
  79   //ast stack
  80   private final static int AstStackIncrement = 100;
  81   /** The stack of node. */
  82   private static AstNode[] nodes;
  83   /** The cursor in expression stack. */
  84   private static int nodePtr;
  85
  86   public final void setFileToParse(final IFile fileToParse) {
  87     this.fileToParse = fileToParse;
  88   }
  89
  90   public PHPParser() {
  91   }
  92
  93   public PHPParser(final IFile fileToParse) {
  94     this(new StringReader(""));
  95     this.fileToParse = fileToParse;
  96   }
  97
  98   /**
  99    * Reinitialize the parser.
 100    */
 101   private static final void init() {
 102     nodes = new AstNode[AstStackIncrement];
 103     nodePtr = -1;
 104     htmlStart = 0;
 105   }
 106
 107   /**
 108    * Add an php node on the stack.
 109    * @param node the node that will be added to the stack
 110    */
 111   private static final void pushOnAstNodes(AstNode node) {
 112     try {
 113       nodes[++nodePtr] = node;
 114     } catch (IndexOutOfBoundsException e) {
 115       int oldStackLength = nodes.length;
 116       AstNode[] oldStack = nodes;
 117       nodes = new AstNode[oldStackLength + AstStackIncrement];
 118       System.arraycopy(oldStack, 0, nodes, 0, oldStackLength);
 119       nodePtr = oldStackLength;
 120       nodes[nodePtr] = node;
 121     }
 122   }
 123
 124   public final PHPOutlineInfo parseInfo(final Object parent, final String s) {
 125     phpDocument = new PHPDocument(parent,"_root".toCharArray());
 126     currentSegment = phpDocument;
 127     outlineInfo = new PHPOutlineInfo(parent, currentSegment);
 128     final StringReader stream = new StringReader(s);
 129     if (jj_input_stream == null) {
 130       jj_input_stream = new SimpleCharStream(stream, 1, 1);
 131     }
 132     ReInit(stream);
 133     init();
 134     try {
 135       parse();
 136       phpDocument.nodes = new AstNode[nodes.length];
 137       System.arraycopy(nodes,0,phpDocument.nodes,0,nodes.length);
 138       if (PHPeclipsePlugin.DEBUG) {
 139         PHPeclipsePlugin.log(1,phpDocument.toString());
 140       }
 141     } catch (ParseException e) {
 142       processParseException(e);
 143     }
 144     return outlineInfo;
 145   }
 146
 147   /**
 148    * This method will process the parse exception.
 149    * If the error message is null, the parse exception wasn't catched and a trace is written in the log
 150    * @param e the ParseException
 151    */
 152   private static void processParseException(final ParseException e) {
 153     if (errorMessage == null) {
 154       PHPeclipsePlugin.log(e);
 155       errorMessage = "this exception wasn't handled by the parser please tell us how to reproduce it";
 156       errorStart = SimpleCharStream.getPosition();
 157       errorEnd   = errorStart + 1;
 158     }
 159     setMarker(e);
 160     errorMessage = null;
 161   }
 162
 163   /**
 164    * Create marker for the parse error
 165    * @param e the ParseException
 166    */
 167   private static void setMarker(final ParseException e) {
 168     try {
 169       if (errorStart == -1) {
 170         setMarker(fileToParse,
 171                   errorMessage,
 172                   SimpleCharStream.tokenBegin,
 173                   SimpleCharStream.tokenBegin + e.currentToken.image.length(),
 174                   errorLevel,
 175                   "Line " + e.currentToken.beginLine);
 176       } else {
 177         setMarker(fileToParse,
 178                   errorMessage,
 179                   errorStart,
 180                   errorEnd,
 181                   errorLevel,
 182                   "Line " + e.currentToken.beginLine);
 183         errorStart = -1;
 184         errorEnd = -1;
 185       }
 186     } catch (CoreException e2) {
 187       PHPeclipsePlugin.log(e2);
 188     }
 189   }
 190
 191   private static void scanLine(final String output,
 192                                final IFile file,
 193                                final int indx,
 194                                final int brIndx) throws CoreException {
 195     String current;
 196     StringBuffer lineNumberBuffer = new StringBuffer(10);
 197     char ch;
 198     current = output.substring(indx, brIndx);
 199
 200     if (current.indexOf(PARSE_WARNING_STRING) != -1 || current.indexOf(PARSE_ERROR_STRING) != -1) {
 201       int onLine = current.indexOf("on line <b>");
 202       if (onLine != -1) {
 203         lineNumberBuffer.delete(0, lineNumberBuffer.length());
 204         for (int i = onLine; i < current.length(); i++) {
 205           ch = current.charAt(i);
 206           if ('0' <= ch && '9' >= ch) {
 207             lineNumberBuffer.append(ch);
 208           }
 209         }
 210
 211         int lineNumber = Integer.parseInt(lineNumberBuffer.toString());
 212
 213         Hashtable attributes = new Hashtable();
 214
 215         current = current.replaceAll("\n", "");
 216         current = current.replaceAll("<b>", "");
 217         current = current.replaceAll("</b>", "");
 218         MarkerUtilities.setMessage(attributes, current);
 219
 220         if (current.indexOf(PARSE_ERROR_STRING) != -1)
 221           attributes.put(IMarker.SEVERITY, new Integer(IMarker.SEVERITY_ERROR));
 222         else if (current.indexOf(PARSE_WARNING_STRING) != -1)
 223           attributes.put(IMarker.SEVERITY, new Integer(IMarker.SEVERITY_WARNING));
 224         else
 225           attributes.put(IMarker.SEVERITY, new Integer(IMarker.SEVERITY_INFO));
 226         MarkerUtilities.setLineNumber(attributes, lineNumber);
 227         MarkerUtilities.createMarker(file, attributes, IMarker.PROBLEM);
 228       }
 229     }
 230   }
 231
 232   public final void parse(final String s) throws CoreException {
 233     final StringReader stream = new StringReader(s);
 234     if (jj_input_stream == null) {
 235       jj_input_stream = new SimpleCharStream(stream, 1, 1);
 236     }
 237     ReInit(stream);
 238     init();
 239     try {
 240       parse();
 241     } catch (ParseException e) {
 242       processParseException(e);
 243     }
 244   }
 245
 246   /**
 247    * Call the php parse command ( php -l -f &lt;filename&gt; )
 248    * and create markers according to the external parser output
 249    */
 250   public static void phpExternalParse(final IFile file) {
 251     final IPreferenceStore store = PHPeclipsePlugin.getDefault().getPreferenceStore();
 252     final String filename = file.getLocation().toString();
 253
 254     final String[] arguments = { filename };
 255     final MessageFormat form = new MessageFormat(store.getString(PHPeclipsePlugin.EXTERNAL_PARSER_PREF));
 256     final String command = form.format(arguments);
 257
 258     final String parserResult = PHPStartApacheAction.getParserOutput(command, "External parser: ");
 259
 260     try {
 261       // parse the buffer to find the errors and warnings
 262       createMarkers(parserResult, file);
 263     } catch (CoreException e) {
 264       PHPeclipsePlugin.log(e);
 265     }
 266   }
 267
 268   /**
 269    * Put a new html block in the stack.
 270    */
 271   public static final void createNewHTMLCode() {
 272     final int currentPosition = SimpleCharStream.getPosition();
 273     if (currentPosition == htmlStart || currentPosition > SimpleCharStream.currentBuffer.length()) {
 274       return;
 275     }
 276     final char[] chars = SimpleCharStream.currentBuffer.substring(htmlStart,currentPosition+1).toCharArray();
 277     pushOnAstNodes(new HTMLCode(chars, htmlStart,currentPosition));
 278   }
 279
 280   /**
 281    * Create a new task.
 282    */
 283   public static final void createNewTask() {
 284     final int currentPosition = SimpleCharStream.getPosition();
 285     final String  todo = SimpleCharStream.currentBuffer.substring(currentPosition+1,
 286                                                                   SimpleCharStream.currentBuffer.indexOf("\n",
 287                                                                                                          currentPosition)-1);
 288     try {
 289       setMarker(fileToParse,
 290                 "todo : " + todo,
 291                 SimpleCharStream.getBeginLine(),
 292                 TASK,
 293                 "Line "+SimpleCharStream.getBeginLine());
 294     } catch (CoreException e) {
 295       PHPeclipsePlugin.log(e);
 296     }
 297   }
 298
 299   private static final void parse() throws ParseException {
 300           phpFile();
 301   }
 302 }
 303
 304 PARSER_END(PHPParser)
 305
 306 <DEFAULT> TOKEN :
 307 {
 308   <PHPSTARTSHORT : "<?">    {PHPParser.createNewHTMLCode();} : PHPPARSING
 309 | <PHPSTARTLONG  : "<?php"> {PHPParser.createNewHTMLCode();} : PHPPARSING
 310 | <PHPECHOSTART  : "<?=">   {PHPParser.createNewHTMLCode();} : PHPPARSING
 311 }
 312
 313 <PHPPARSING> TOKEN :
 314 {
 315   <PHPEND :"?>"> {PHPParser.htmlStart = SimpleCharStream.getPosition();} : DEFAULT
 316 }
 317
 318 /* Skip any character if we are not in php mode */
 319 <DEFAULT> SKIP :
 320 {
 321  < ~[] >
 322 }
 323
 324
 325 /* WHITE SPACE */
 326 <PHPPARSING> SKIP :
 327 {
 328   " "
 329 | "\t"
 330 | "\n"
 331 | "\r"
 332 | "\f"
 333 }
 334
 335 /* COMMENTS */
 336 <PHPPARSING> SPECIAL_TOKEN :
 337 {
 338   "//" : IN_SINGLE_LINE_COMMENT
 339 | "#"  : IN_SINGLE_LINE_COMMENT
 340 | <"/**" ~["/"]> { input_stream.backup(1); } : IN_FORMAL_COMMENT
 341 | "/*" : IN_MULTI_LINE_COMMENT
 342 }
 343
 344 <IN_SINGLE_LINE_COMMENT> SPECIAL_TOKEN :
 345 {
 346   <SINGLE_LINE_COMMENT: "\n" | "\r" | "\r\n" > : PHPPARSING
 347 | "?>" : DEFAULT
 348 }
 349
 350 <IN_SINGLE_LINE_COMMENT,IN_FORMAL_COMMENT,IN_MULTI_LINE_COMMENT> SPECIAL_TOKEN :
 351 {
 352  "todo" {PHPParser.createNewTask();}
 353 }
 354
 355 <IN_FORMAL_COMMENT> SPECIAL_TOKEN :
 356 {
 357   "*/" : PHPPARSING
 358 }
 359
 360 <IN_MULTI_LINE_COMMENT> SPECIAL_TOKEN :
 361 {
 362   "*/" : PHPPARSING
 363 }
 364
 365 <IN_SINGLE_LINE_COMMENT,IN_FORMAL_COMMENT,IN_MULTI_LINE_COMMENT>
 366 MORE :
 367 {
 368   < ~[] >
 369 }
 370
 371 /* KEYWORDS */
 372 <PHPPARSING> TOKEN :
 373 {
 374   <CLASS    : "class">
 375 | <FUNCTION : "function">
 376 | <VAR      : "var">
 377 | <IF       : "if">
 378 | <ELSEIF   : "elseif">
 379 | <ELSE     : "else">
 380 | <ARRAY    : "array">
 381 | <BREAK    : "break">
 382 | <LIST     : "list">
 383 }
 384
 385 /* LANGUAGE CONSTRUCT */
 386 <PHPPARSING> TOKEN :
 387 {
 388   <PRINT              : "print">
 389 | <ECHO               : "echo">
 390 | <INCLUDE            : "include">
 391 | <REQUIRE            : "require">
 392 | <INCLUDE_ONCE       : "include_once">
 393 | <REQUIRE_ONCE       : "require_once">
 394 | <GLOBAL             : "global">
 395 | <DEFINE             : "define">
 396 | <STATIC             : "static">
 397 | <CLASSACCESS        : "->">
 398 | <STATICCLASSACCESS  : "::">
 399 | <ARRAYASSIGN        : "=>">
 400 }
 401
 402 /* RESERVED WORDS AND LITERALS */
 403
 404 <PHPPARSING> TOKEN :
 405 {
 406   <CASE     : "case">
 407 | <CONST    : "const">
 408 | <CONTINUE : "continue">
 409 | <_DEFAULT : "default">
 410 | <DO       : "do">
 411 | <EXTENDS  : "extends">
 412 | <FOR      : "for">
 413 | <GOTO     : "goto">
 414 | <NEW      : "new">
 415 | <NULL     : "null">
 416 | <RETURN   : "return">
 417 | <SUPER    : "super">
 418 | <SWITCH   : "switch">
 419 | <THIS     : "this">
 420 | <TRUE     : "true">
 421 | <FALSE    : "false">
 422 | <WHILE    : "while">
 423 | <ENDWHILE : "endwhile">
 424 | <ENDSWITCH: "endswitch">
 425 | <ENDIF    : "endif">
 426 | <ENDFOR   : "endfor">
 427 | <FOREACH  : "foreach">
 428 | <AS       : "as" >
 429 }
 430
 431 /* TYPES */
 432 <PHPPARSING> TOKEN :
 433 {
 434   <STRING  : "string">
 435 | <OBJECT  : "object">
 436 | <BOOL    : "bool">
 437 | <BOOLEAN : "boolean">
 438 | <REAL    : "real">
 439 | <DOUBLE  : "double">
 440 | <FLOAT   : "float">
 441 | <INT     : "int">
 442 | <INTEGER : "integer">
 443 }
 444
 445 //Misc token
 446 <PHPPARSING> TOKEN :
 447 {
 448   <AT                 : "@">
 449 | <DOLLAR             : "$">
 450 | <BANG               : "!">
 451 | <TILDE              : "~">
 452 | <HOOK               : "?">
 453 | <COLON              : ":">
 454 }
 455
 456 /* OPERATORS */
 457 <PHPPARSING> TOKEN :
 458 {
 459   <OR_OR              : "||">
 460 | <AND_AND            : "&&">
 461 | <PLUS_PLUS          : "++">
 462 | <MINUS_MINUS        : "--">
 463 | <PLUS               : "+">
 464 | <MINUS              : "-">
 465 | <STAR               : "*">
 466 | <SLASH              : "/">
 467 | <BIT_AND            : "&">
 468 | <BIT_OR             : "|">
 469 | <XOR                : "^">
 470 | <REMAINDER          : "%">
 471 | <LSHIFT             : "<<">
 472 | <RSIGNEDSHIFT       : ">>">
 473 | <RUNSIGNEDSHIFT     : ">>>">
 474 | <_ORL               : "OR">
 475 | <_ANDL              : "AND">
 476 }
 477
 478 /* LITERALS */
 479 <PHPPARSING> TOKEN :
 480 {
 481   <INTEGER_LITERAL:
 482         <DECIMAL_LITERAL> (["l","L"])?
 483       | <HEX_LITERAL> (["l","L"])?
 484       | <OCTAL_LITERAL> (["l","L"])?
 485   >
 486 |
 487   <#DECIMAL_LITERAL: ["1"-"9"] (["0"-"9"])* >
 488 |
 489   <#HEX_LITERAL: "0" ["x","X"] (["0"-"9","a"-"f","A"-"F"])+ >
 490 |
 491   <#OCTAL_LITERAL: "0" (["0"-"7"])* >
 492 |
 493   <FLOATING_POINT_LITERAL:
 494         (["0"-"9"])+ "." (["0"-"9"])* (<EXPONENT>)? (["f","F","d","D"])?
 495       | "." (["0"-"9"])+ (<EXPONENT>)? (["f","F","d","D"])?
 496       | (["0"-"9"])+ <EXPONENT> (["f","F","d","D"])?
 497       | (["0"-"9"])+ (<EXPONENT>)? ["f","F","d","D"]
 498   >
 499 |
 500   <#EXPONENT: ["e","E"] (["+","-"])? (["0"-"9"])+ >
 501 |
 502   <STRING_LITERAL: (<STRING_1> | <STRING_2> | <STRING_3>)>
 503 |   <STRING_1: "\"" ( ~["\""] | "\\\"" | "\\" )* "\"">
 504 |   <STRING_2: "'" ( ~["'"] | "\\'" )* "'">
 505 |   <STRING_3: "`" ( ~["`"] | "\\`" )* "`">
 506 }
 507
 508 /* IDENTIFIERS */
 509
 510 <PHPPARSING> TOKEN :
 511 {
 512   < IDENTIFIER: (<LETTER>|<SPECIAL>) (<LETTER>|<DIGIT>|<SPECIAL>)* >
 513 |
 514   < #LETTER:
 515       ["a"-"z"] | ["A"-"Z"]
 516   >
 517 |
 518   < #DIGIT:
 519       ["0"-"9"]
 520   >
 521 |
 522   < #SPECIAL:
 523     "_" | ["\u007f"-"\u00ff"]
 524   >
 525 }
 526
 527 /* SEPARATORS */
 528
 529 <PHPPARSING> TOKEN :
 530 {
 531   <LPAREN    : "(">
 532 | <RPAREN    : ")">
 533 | <LBRACE    : "{">
 534 | <RBRACE    : "}">
 535 | <LBRACKET  : "[">
 536 | <RBRACKET  : "]">
 537 | <SEMICOLON : ";">
 538 | <COMMA     : ",">
 539 | <DOT       : ".">
 540 }
 541
 542
 543 /* COMPARATOR */
 544 <PHPPARSING> TOKEN :
 545 {
 546   <GT                 : ">">
 547 | <LT                 : "<">
 548 | <EQUAL_EQUAL        : "==">
 549 | <LE                 : "<=">
 550 | <GE                 : ">=">
 551 | <NOT_EQUAL          : "!=">
 552 | <DIF                : "<>">
 553 | <BANGDOUBLEEQUAL    : "!==">
 554 | <TRIPLEEQUAL        : "===">
 555 }
 556
 557 /* ASSIGNATION */
 558 <PHPPARSING> TOKEN :
 559 {
 560   <ASSIGN             : "=">
 561 | <PLUSASSIGN         : "+=">
 562 | <MINUSASSIGN        : "-=">
 563 | <STARASSIGN         : "*=">
 564 | <SLASHASSIGN        : "/=">
 565 | <ANDASSIGN          : "&=">
 566 | <ORASSIGN           : "|=">
 567 | <XORASSIGN          : "^=">
 568 | <DOTASSIGN          : ".=">
 569 | <REMASSIGN          : "%=">
 570 | <TILDEEQUAL         : "~=">
 571 | <LSHIFTASSIGN       : "<<=">
 572 | <RSIGNEDSHIFTASSIGN : ">>=">
 573 }
 574
 575 <PHPPARSING> TOKEN :
 576 {
 577   <DOLLAR_ID: <DOLLAR> <IDENTIFIER>>
 578 }
 579
 580 void phpFile() :
 581 {}
 582 {
 583   try {
 584     (PhpBlock())*
 585     {PHPParser.createNewHTMLCode();}
 586   } catch (TokenMgrError e) {
 587     PHPeclipsePlugin.log(e);
 588     errorStart   = SimpleCharStream.getPosition();
 589     errorEnd     = errorStart + 1;
 590     errorMessage = e.getMessage();
 591     errorLevel   = ERROR;
 592     throw generateParseException();
 593   }
 594 }
 595
 596 /**
 597  * A php block is a <?= expression [;]?>
 598  * or <?php somephpcode ?>
 599  * or <? somephpcode ?>
 600  */
 601 void PhpBlock() :
 602 {
 603   final int start = SimpleCharStream.getPosition();
 604   final PHPEchoBlock phpEchoBlock;
 605 }
 606 {
 607   phpEchoBlock = phpEchoBlock()
 608   {pushOnAstNodes(phpEchoBlock);}
 609 |
 610   [   <PHPSTARTLONG>
 611     | <PHPSTARTSHORT>
 612     {try {
 613       setMarker(fileToParse,
 614                 "You should use '<?php' instead of '<?' it will avoid some problems with XML",
 615                 start,
 616                 SimpleCharStream.getPosition(),
 617                 INFO,
 618                 "Line " + token.beginLine);
 619     } catch (CoreException e) {
 620       PHPeclipsePlugin.log(e);
 621     }}
 622   ]
 623   Php()
 624   try {
 625     <PHPEND>
 626   } catch (ParseException e) {
 627     errorMessage = "'?>' expected";
 628     errorLevel   = ERROR;
 629     errorStart = SimpleCharStream.getPosition() - e.currentToken.next.image.length() + 1;
 630     errorEnd   = SimpleCharStream.getPosition() + 1;
 631     processParseException(e);
 632   }
 633 }
 634
 635 PHPEchoBlock phpEchoBlock() :
 636 {
 637   final Expression expr;
 638   final int pos = SimpleCharStream.getPosition();
 639   PHPEchoBlock echoBlock;
 640 }
 641 {
 642   <PHPECHOSTART> expr = Expression() [ <SEMICOLON> ] <PHPEND>
 643   {
 644   echoBlock = new PHPEchoBlock(expr,pos,SimpleCharStream.getPosition());
 645   pushOnAstNodes(echoBlock);
 646   return echoBlock;}
 647 }
 648
 649 void Php() :
 650 {}
 651 {
 652   (BlockStatement())*
 653 }
 654
 655 ClassDeclaration ClassDeclaration() :
 656 {
 657   final ClassDeclaration classDeclaration;
 658   final Token className;
 659   Token superclassName = null;
 660   final int pos;
 661   char[] classNameImage = SYNTAX_ERROR_CHAR;
 662   char[] superclassNameImage = null;
 663 }
 664 {
 665   <CLASS>
 666   {pos = SimpleCharStream.getPosition();}
 667   try {
 668     className = <IDENTIFIER>
 669     {classNameImage = className.image.toCharArray();}
 670   } catch (ParseException e) {
 671     errorMessage = "unexpected token : '"+ e.currentToken.next.image +"', identifier expected";
 672     errorLevel   = ERROR;
 673     errorStart   = SimpleCharStream.getPosition() - e.currentToken.next.image.length() + 1;
 674     errorEnd     = SimpleCharStream.getPosition() + 1;
 675     processParseException(e);
 676   }
 677   [
 678     <EXTENDS>
 679     try {
 680       superclassName = <IDENTIFIER>
 681       {superclassNameImage = superclassName.image.toCharArray();}
 682     } catch (ParseException e) {
 683       errorMessage = "unexpected token : '"+ e.currentToken.next.image +"', identifier expected";
 684       errorLevel   = ERROR;
 685       errorStart = SimpleCharStream.getPosition() - e.currentToken.next.image.length() + 1;
 686       errorEnd   = SimpleCharStream.getPosition() + 1;
 687       processParseException(e);
 688       superclassNameImage = SYNTAX_ERROR_CHAR;
 689     }
 690   ]
 691   {
 692     if (superclassNameImage == null) {
 693       classDeclaration = new ClassDeclaration(currentSegment,
 694                                               classNameImage,
 695                                               pos,
 696                                               0);
 697     } else {
 698       classDeclaration = new ClassDeclaration(currentSegment,
 699                                               classNameImage,
 700                                               superclassNameImage,
 701                                               pos,
 702                                               0);
 703     }
 704       currentSegment.add(classDeclaration);
 705       currentSegment = classDeclaration;
 706   }
 707   ClassBody(classDeclaration)
 708   {currentSegment = (OutlineableWithChildren) currentSegment.getParent();
 709    classDeclaration.sourceEnd = SimpleCharStream.getPosition();
 710    pushOnAstNodes(classDeclaration);
 711    return classDeclaration;}
 712 }
 713
 714 void ClassBody(ClassDeclaration classDeclaration) :
 715 {}
 716 {
 717   try {
 718     <LBRACE>
 719   } catch (ParseException e) {
 720     errorMessage = "unexpected token : '"+ e.currentToken.next.image + "', '{' expected";
 721     errorLevel   = ERROR;
 722     errorStart = SimpleCharStream.getPosition() - e.currentToken.next.image.length() + 1;
 723     errorEnd   = SimpleCharStream.getPosition() + 1;
 724     throw e;
 725   }
 726   ( ClassBodyDeclaration(classDeclaration) )*
 727   try {
 728     <RBRACE>
 729   } catch (ParseException e) {
 730     errorMessage = "unexpected token : '"+ e.currentToken.next.image +"', 'var', 'function' or '}' expected";
 731     errorLevel   = ERROR;
 732     errorStart = SimpleCharStream.getPosition() - e.currentToken.next.image.length() + 1;
 733     errorEnd   = SimpleCharStream.getPosition() + 1;
 734     throw e;
 735   }
 736 }
 737
 738 /**
 739  * A class can contain only methods and fields.
 740  */
 741 void ClassBodyDeclaration(ClassDeclaration classDeclaration) :
 742 {
 743   MethodDeclaration method;
 744   FieldDeclaration field;
 745 }
 746 {
 747   method = MethodDeclaration() {classDeclaration.addMethod(method);}
 748 | field = FieldDeclaration()   {classDeclaration.addField(field);}
 749 }
 750
 751 /**
 752  * A class field declaration : it's var VariableDeclarator() (, VariableDeclarator())*;.
 753  */
 754 FieldDeclaration FieldDeclaration() :
 755 {
 756   VariableDeclaration variableDeclaration;
 757   VariableDeclaration[] list;
 758   final ArrayList arrayList = new ArrayList();
 759   final int pos = SimpleCharStream.getPosition();
 760 }
 761 {
 762   <VAR> variableDeclaration = VariableDeclarator()
 763   {arrayList.add(variableDeclaration);
 764    outlineInfo.addVariable(new String(variableDeclaration.name));}
 765   ( <COMMA> variableDeclaration = VariableDeclarator()
 766       {arrayList.add(variableDeclaration);
 767        outlineInfo.addVariable(new String(variableDeclaration.name));}
 768   )*
 769   try {
 770     <SEMICOLON>
 771   } catch (ParseException e) {
 772     errorMessage = "unexpected token : '"+ e.currentToken.next.image +"'. A ';' was expected after variable declaration";
 773     errorLevel   = ERROR;
 774     errorStart   = SimpleCharStream.getPosition() - e.currentToken.next.image.length() + 1;
 775     errorEnd     = SimpleCharStream.getPosition() + 1;
 776     processParseException(e);
 777   }
 778
 779   {list = new VariableDeclaration[arrayList.size()];
 780    arrayList.toArray(list);
 781    return new FieldDeclaration(list,
 782                                pos,
 783                                SimpleCharStream.getPosition(),
 784                                currentSegment);}
 785 }
 786
 787 VariableDeclaration VariableDeclarator() :
 788 {
 789   final String varName;
 790   Expression initializer = null;
 791   final int pos = SimpleCharStream.getPosition();
 792 }
 793 {
 794   varName = VariableDeclaratorId()
 795   [
 796     <ASSIGN>
 797     try {
 798       initializer = VariableInitializer()
 799     } catch (ParseException e) {
 800       errorMessage = "Literal expression expected in variable initializer";
 801       errorLevel   = ERROR;
 802       errorStart = SimpleCharStream.getPosition() - e.currentToken.next.image.length() + 1;
 803       errorEnd   = SimpleCharStream.getPosition() + 1;
 804       throw e;
 805     }
 806   ]
 807   {
 808   if (initializer == null) {
 809     return new VariableDeclaration(currentSegment,
 810                                   varName.toCharArray(),
 811                                   pos,
 812                                   SimpleCharStream.getPosition());
 813   }
 814     return new VariableDeclaration(currentSegment,
 815                                     varName.toCharArray(),
 816                                     initializer,
 817                                     pos);
 818   }
 819 }
 820
 821 /**
 822  * A Variable name.
 823  * @return the variable name (with suffix)
 824  */
 825 String VariableDeclaratorId() :
 826 {
 827   String expr;
 828   Expression expression = null;
 829   final StringBuffer buff = new StringBuffer();
 830   final int pos = SimpleCharStream.getPosition();
 831   ConstantIdentifier ex;
 832 }
 833 {
 834   try {
 835     expr = Variable()
 836     ( LOOKAHEAD(2)
 837       {ex = new ConstantIdentifier(expr.toCharArray(),
 838                                    pos,
 839                                    SimpleCharStream.getPosition());}
 840       expression = VariableSuffix(ex)
 841     )*
 842     {
 843      if (expression == null) {
 844        return expr;
 845      }
 846      return expression.toStringExpression();
 847     }
 848   } catch (ParseException e) {
 849     errorMessage = "'$' expected for variable identifier";
 850     errorLevel   = ERROR;
 851     errorStart = SimpleCharStream.getPosition() - e.currentToken.next.image.length() + 1;
 852     errorEnd   = SimpleCharStream.getPosition() + 1;
 853     throw e;
 854   }
 855 }
 856
 857 /**
 858  * Return a variablename without the $.
 859  * @return a variable name
 860  */
 861 String Variable():
 862 {
 863   final StringBuffer buff;
 864   Expression expression = null;
 865   final Token token;
 866   final String expr;
 867 }
 868 {
 869   token = <DOLLAR_ID> [<LBRACE> expression = Expression() <RBRACE>]
 870   {
 871     if (expression == null) {
 872       return token.image.substring(1);
 873     }
 874     buff = new StringBuffer(token.image);
 875     buff.append("{");
 876     buff.append(expression.toStringExpression());
 877     buff.append("}");
 878     return buff.toString();
 879   }
 880 |
 881   <DOLLAR> expr = VariableName()
 882   {return expr;}
 883 }
 884
 885 /**
 886  * A Variable name (without the $)
 887  * @return a variable name String
 888  */
 889 String VariableName():
 890 {
 891   final StringBuffer buff;
 892   String expr = null;
 893   Expression expression = null;
 894   final Token token;
 895 }
 896 {
 897   <LBRACE> expression = Expression() <RBRACE>
 898   {buff = new StringBuffer("{");
 899    buff.append(expression.toStringExpression());
 900    buff.append("}");
 901    return buff.toString();}
 902 |
 903   token = <IDENTIFIER> [<LBRACE> expression = Expression() <RBRACE>]
 904   {
 905     if (expression == null) {
 906       return token.image;
 907     }
 908     buff = new StringBuffer(token.image);
 909     buff.append("{");
 910     buff.append(expression.toStringExpression());
 911     buff.append("}");
 912     return buff.toString();
 913   }
 914 |
 915   <DOLLAR> expr = VariableName()
 916   {
 917     buff = new StringBuffer("$");
 918     buff.append(expr);
 919     return buff.toString();
 920   }
 921 |
 922   token = <DOLLAR_ID> {return token.image;}
 923 }
 924
 925 Expression VariableInitializer() :
 926 {
 927   final Expression expr;
 928   final Token token;
 929   final int pos = SimpleCharStream.getPosition();
 930 }
 931 {
 932   expr = Literal()
 933   {return expr;}
 934 |
 935   <MINUS> (token = <INTEGER_LITERAL> | token = <FLOATING_POINT_LITERAL>)
 936   {return new PrefixedUnaryExpression(new NumberLiteral(token.image.toCharArray(),
 937                                                         pos,
 938                                                         SimpleCharStream.getPosition()),
 939                                       OperatorIds.MINUS,
 940                                       pos);}
 941 |
 942   <PLUS> (token = <INTEGER_LITERAL> | token = <FLOATING_POINT_LITERAL>)
 943   {return new PrefixedUnaryExpression(new NumberLiteral(token.image.toCharArray(),
 944                                                         pos,
 945                                                         SimpleCharStream.getPosition()),
 946                                       OperatorIds.PLUS,
 947                                       pos);}
 948 |
 949   expr = ArrayDeclarator()
 950   {return expr;}
 951 |
 952   token = <IDENTIFIER>
 953   {return new ConstantIdentifier(token.image.toCharArray(),pos,SimpleCharStream.getPosition());}
 954 }
 955
 956 ArrayVariableDeclaration ArrayVariable() :
 957 {
 958 Expression expr,expr2;
 959 }
 960 {
 961   expr = Expression()
 962   [<ARRAYASSIGN> expr2 = Expression()
 963   {return new ArrayVariableDeclaration(expr,expr2);}
 964   ]
 965   {return new ArrayVariableDeclaration(expr,SimpleCharStream.getPosition());}
 966 }
 967
 968 ArrayVariableDeclaration[] ArrayInitializer() :
 969 {
 970   ArrayVariableDeclaration expr;
 971   final ArrayList list = new ArrayList();
 972 }
 973 {
 974   <LPAREN> [ expr = ArrayVariable()
 975             {list.add(expr);}
 976             ( LOOKAHEAD(2) <COMMA> expr = ArrayVariable()
 977             {list.add(expr);}
 978             )*
 979            ]
 980            [<COMMA> {list.add(null);}]
 981   <RPAREN>
 982   {
 983   ArrayVariableDeclaration[] vars = new ArrayVariableDeclaration[list.size()];
 984   list.toArray(vars);
 985   return vars;}
 986 }
 987
 988 /**
 989  * A Method Declaration.
 990  * <b>function</b> MetodDeclarator() Block()
 991  */
 992 MethodDeclaration MethodDeclaration() :
 993 {
 994   final MethodDeclaration functionDeclaration;
 995   final Block block;
 996   final OutlineableWithChildren seg = currentSegment;
 997 }
 998 {
 999   <FUNCTION>
1000   try {
1001     functionDeclaration = MethodDeclarator()
1002     {outlineInfo.addVariable(new String(functionDeclaration.name));}
1003   } catch (ParseException e) {
1004     if (errorMessage != null)  throw e;
1005     errorMessage = "unexpected token : '"+ e.currentToken.next.image +"', function identifier expected";
1006     errorLevel   = ERROR;
1007     errorStart = SimpleCharStream.getPosition() - e.currentToken.next.image.length() + 1;
1008     errorEnd   = SimpleCharStream.getPosition() + 1;
1009     throw e;
1010   }
1011   {currentSegment = functionDeclaration;}
1012   block = Block()
1013   {functionDeclaration.statements = block.statements;
1014    currentSegment = seg;
1015    return functionDeclaration;}
1016 }
1017
1018 /**
1019  * A MethodDeclarator.
1020  * [&] IDENTIFIER(parameters ...).
1021  * @return a function description for the outline
1022  */
1023 MethodDeclaration MethodDeclarator() :
1024 {
1025   final Token identifier;
1026   Token reference = null;
1027   final Hashtable formalParameters;
1028   final int pos = SimpleCharStream.getPosition();
1029   char[] identifierChar = SYNTAX_ERROR_CHAR;
1030 }
1031 {
1032   [reference = <BIT_AND>]
1033   try {
1034     identifier = <IDENTIFIER>
1035     {identifierChar = identifier.image.toCharArray();}
1036   } catch (ParseException e) {
1037     errorMessage = "unexpected token : '"+ e.currentToken.next.image +"', function identifier expected";
1038     errorLevel   = ERROR;
1039     errorStart = SimpleCharStream.getPosition() - e.currentToken.next.image.length() + 1;
1040     errorEnd   = SimpleCharStream.getPosition() + 1;
1041     processParseException(e);
1042   }
1043   formalParameters = FormalParameters()
1044   {return new MethodDeclaration(currentSegment,
1045                                 identifierChar,
1046                                 formalParameters,
1047                                 reference != null,
1048                                 pos,
1049                                 SimpleCharStream.getPosition());}
1050 }
1051
1052 /**
1053  * FormalParameters follows method identifier.
1054  * (FormalParameter())
1055  */
1056 Hashtable FormalParameters() :
1057 {
1058   VariableDeclaration var;
1059   final Hashtable parameters = new Hashtable();
1060 }
1061 {
1062   try {
1063   <LPAREN>
1064   } catch (ParseException e) {
1065     errorMessage = "unexpected token : '"+ e.currentToken.next.image +"', '(' expected after function identifier";
1066     errorLevel   = ERROR;
1067     errorStart = SimpleCharStream.getPosition() - e.currentToken.next.image.length() + 1;
1068     errorEnd   = SimpleCharStream.getPosition() + 1;
1069     processParseException(e);
1070   }
1071             [ var = FormalParameter()
1072               {parameters.put(new String(var.name),var);}
1073               (
1074                 <COMMA> var = FormalParameter()
1075                 {parameters.put(new String(var.name),var);}
1076               )*
1077             ]
1078   try {
1079     <RPAREN>
1080   } catch (ParseException e) {
1081     errorMessage = "')' expected";
1082     errorLevel   = ERROR;
1083     errorStart = SimpleCharStream.getPosition() - e.currentToken.next.image.length() + 1;
1084     errorEnd   = SimpleCharStream.getPosition() + 1;
1085     processParseException(e);
1086   }
1087  {return parameters;}
1088 }
1089
1090 /**
1091  * A formal parameter.
1092  * $varname[=value] (,$varname[=value])
1093  */
1094 VariableDeclaration FormalParameter() :
1095 {
1096   final VariableDeclaration variableDeclaration;
1097   Token token = null;
1098 }
1099 {
1100   [token = <BIT_AND>] variableDeclaration = VariableDeclarator()
1101   {
1102     if (token != null) {
1103       variableDeclaration.setReference(true);
1104     }
1105     return variableDeclaration;}
1106 }
1107
1108 ConstantIdentifier Type() :
1109 {final int pos;}
1110 {
1111   <STRING>             {pos = SimpleCharStream.getPosition();
1112                         return new ConstantIdentifier(Types.STRING,pos,pos-6);}
1113 | <BOOL>               {pos = SimpleCharStream.getPosition();
1114                         return new ConstantIdentifier(Types.BOOL,pos,pos-4);}
1115 | <BOOLEAN>            {pos = SimpleCharStream.getPosition();
1116                         return new ConstantIdentifier(Types.BOOLEAN,pos,pos-7);}
1117 | <REAL>               {pos = SimpleCharStream.getPosition();
1118                         return new ConstantIdentifier(Types.REAL,pos,pos-4);}
1119 | <DOUBLE>             {pos = SimpleCharStream.getPosition();
1120                         return new ConstantIdentifier(Types.DOUBLE,pos,pos-5);}
1121 | <FLOAT>              {pos = SimpleCharStream.getPosition();
1122                         return new ConstantIdentifier(Types.FLOAT,pos,pos-5);}
1123 | <INT>                {pos = SimpleCharStream.getPosition();
1124                         return new ConstantIdentifier(Types.INT,pos,pos-3);}
1125 | <INTEGER>            {pos = SimpleCharStream.getPosition();
1126                         return new ConstantIdentifier(Types.INTEGER,pos,pos-7);}
1127 | <OBJECT>             {pos = SimpleCharStream.getPosition();
1128                         return new ConstantIdentifier(Types.OBJECT,pos,pos-6);}
1129 }
1130
1131 Expression Expression() :
1132 {
1133   final Expression expr;
1134   Token bangToken = null;
1135   final int pos = SimpleCharStream.getPosition();
1136 }
1137 {
1138   <BANG> expr = Expression() {return new PrefixedUnaryExpression(expr,OperatorIds.NOT,pos);}
1139 | expr = ExpressionNoBang() {return expr;}
1140 }
1141
1142 Expression ExpressionNoBang() :
1143 {
1144   final Expression expr;
1145 }
1146 {
1147   expr = PrintExpression()       {return expr;}
1148 | expr = ListExpression()        {return expr;}
1149 | LOOKAHEAD(varAssignation())
1150   expr = varAssignation()        {return expr;}
1151 | expr = ConditionalExpression() {return expr;}
1152 }
1153
1154 /**
1155  * A Variable assignation.
1156  * varName (an assign operator) any expression
1157  */
1158 VarAssignation varAssignation() :
1159 {
1160   String varName;
1161   final Expression initializer;
1162   final int assignOperator;
1163   final int pos = SimpleCharStream.getPosition();
1164 }
1165 {
1166   varName = VariableDeclaratorId()
1167   assignOperator = AssignmentOperator()
1168     try {
1169       initializer = Expression()
1170     } catch (ParseException e) {
1171       if (errorMessage != null) {
1172         throw e;
1173       }
1174       errorMessage = "expression expected";
1175       errorLevel   = ERROR;
1176       errorStart = SimpleCharStream.getPosition() - e.currentToken.next.image.length() + 1;
1177       errorEnd   = SimpleCharStream.getPosition() + 1;
1178       throw e;
1179     }
1180     {return new VarAssignation(varName.toCharArray(),
1181                                initializer,
1182                                assignOperator,
1183                                pos,
1184                                SimpleCharStream.getPosition());}
1185 }
1186
1187 int AssignmentOperator() :
1188 {}
1189 {
1190   <ASSIGN>             {return VarAssignation.EQUAL;}
1191 | <STARASSIGN>         {return VarAssignation.STAR_EQUAL;}
1192 | <SLASHASSIGN>        {return VarAssignation.SLASH_EQUAL;}
1193 | <REMASSIGN>          {return VarAssignation.REM_EQUAL;}
1194 | <PLUSASSIGN>         {return VarAssignation.PLUS_EQUAL;}
1195 | <MINUSASSIGN>        {return VarAssignation.MINUS_EQUAL;}
1196 | <LSHIFTASSIGN>       {return VarAssignation.LSHIFT_EQUAL;}
1197 | <RSIGNEDSHIFTASSIGN> {return VarAssignation.RSIGNEDSHIFT_EQUAL;}
1198 | <ANDASSIGN>          {return VarAssignation.AND_EQUAL;}
1199 | <XORASSIGN>          {return VarAssignation.XOR_EQUAL;}
1200 | <ORASSIGN>           {return VarAssignation.OR_EQUAL;}
1201 | <DOTASSIGN>          {return VarAssignation.DOT_EQUAL;}
1202 | <TILDEEQUAL>         {return VarAssignation.TILDE_EQUAL;}
1203 }
1204
1205 Expression ConditionalExpression() :
1206 {
1207   final Expression expr;
1208   Expression expr2 = null;
1209   Expression expr3 = null;
1210 }
1211 {
1212   expr = ConditionalOrExpression() [ <HOOK> expr2 = Expression() <COLON> expr3 = ConditionalExpression() ]
1213 {
1214   if (expr3 == null) {
1215     return expr;
1216   }
1217   return new ConditionalExpression(expr,expr2,expr3);
1218 }
1219 }
1220
1221 Expression ConditionalOrExpression() :
1222 {
1223   Expression expr,expr2;
1224   int operator;
1225 }
1226 {
1227   expr = ConditionalAndExpression()
1228   (
1229     (
1230         <OR_OR> {operator = OperatorIds.OR_OR;}
1231       | <_ORL>  {operator = OperatorIds.ORL;}
1232     ) expr2 = ConditionalAndExpression()
1233     {
1234       expr = new BinaryExpression(expr,expr2,operator);
1235     }
1236   )*
1237   {return expr;}
1238 }
1239
1240 Expression ConditionalAndExpression() :
1241 {
1242   Expression expr,expr2;
1243   int operator;
1244 }
1245 {
1246   expr = ConcatExpression()
1247   (
1248   (  <AND_AND> {operator = OperatorIds.AND_AND;}
1249    | <_ANDL>   {operator = OperatorIds.ANDL;})
1250    expr2 = ConcatExpression() {expr = new BinaryExpression(expr,expr2,operator);}
1251   )*
1252   {return expr;}
1253 }
1254
1255 Expression ConcatExpression() :
1256 {
1257   Expression expr,expr2;
1258 }
1259 {
1260   expr = InclusiveOrExpression()
1261   (
1262     <DOT> expr2 = InclusiveOrExpression()
1263     {expr = new BinaryExpression(expr,expr2,OperatorIds.DOT);}
1264   )*
1265   {return expr;}
1266 }
1267
1268 Expression InclusiveOrExpression() :
1269 {
1270   Expression expr,expr2;
1271 }
1272 {
1273   expr = ExclusiveOrExpression()
1274   (<BIT_OR> expr2 = ExclusiveOrExpression()
1275    {expr = new BinaryExpression(expr,expr2,OperatorIds.OR);}
1276   )*
1277   {return expr;}
1278 }
1279
1280 Expression ExclusiveOrExpression() :
1281 {
1282   Expression expr,expr2;
1283 }
1284 {
1285   expr = AndExpression()
1286   (
1287     <XOR> expr2 = AndExpression()
1288     {expr = new BinaryExpression(expr,expr2,OperatorIds.XOR);}
1289   )*
1290   {return expr;}
1291 }
1292
1293 Expression AndExpression() :
1294 {
1295   Expression expr,expr2;
1296 }
1297 {
1298   expr = EqualityExpression()
1299   (
1300     <BIT_AND> expr2 = EqualityExpression()
1301     {expr = new BinaryExpression(expr,expr2,OperatorIds.AND);}
1302   )*
1303   {return expr;}
1304 }
1305
1306 Expression EqualityExpression() :
1307 {
1308   Expression expr,expr2;
1309   int operator;
1310 }
1311 {
1312   expr = RelationalExpression()
1313   (
1314   (   <EQUAL_EQUAL>      {operator = OperatorIds.EQUAL_EQUAL;}
1315     | <DIF>              {operator = OperatorIds.DIF;}
1316     | <NOT_EQUAL>        {operator = OperatorIds.DIF;}
1317     | <BANGDOUBLEEQUAL>  {operator = OperatorIds.BANG_EQUAL_EQUAL;}
1318     | <TRIPLEEQUAL>      {operator = OperatorIds.EQUAL_EQUAL_EQUAL;}
1319   )
1320   try {
1321     expr2 = RelationalExpression()
1322   } catch (ParseException e) {
1323     if (errorMessage != null) {
1324       throw e;
1325     }
1326     errorMessage = "unexpected token : '"+ e.currentToken.next.image +"', expression expected";
1327     errorLevel   = ERROR;
1328     errorStart = SimpleCharStream.getPosition() - e.currentToken.next.image.length() + 1;
1329     errorEnd   = SimpleCharStream.getPosition() + 1;
1330     throw e;
1331   }
1332   {
1333     expr = new BinaryExpression(expr,expr2,operator);
1334   }
1335   )*
1336   {return expr;}
1337 }
1338
1339 Expression RelationalExpression() :
1340 {
1341   Expression expr,expr2;
1342   int operator;
1343 }
1344 {
1345   expr = ShiftExpression()
1346   (
1347   ( <LT> {operator = OperatorIds.LESS;}
1348   | <GT> {operator = OperatorIds.GREATER;}
1349   | <LE> {operator = OperatorIds.LESS_EQUAL;}
1350   | <GE> {operator = OperatorIds.GREATER_EQUAL;})
1351    expr2 = ShiftExpression()
1352   {expr = new BinaryExpression(expr,expr2,operator);}
1353   )*
1354   {return expr;}
1355 }
1356
1357 Expression ShiftExpression() :
1358 {
1359   Expression expr,expr2;
1360   int operator;
1361 }
1362 {
1363   expr = AdditiveExpression()
1364   (
1365   ( <LSHIFT>         {operator = OperatorIds.LEFT_SHIFT;}
1366   | <RSIGNEDSHIFT>   {operator = OperatorIds.RIGHT_SHIFT;}
1367   | <RUNSIGNEDSHIFT> {operator = OperatorIds.UNSIGNED_RIGHT_SHIFT;})
1368   expr2 = AdditiveExpression()
1369   {expr = new BinaryExpression(expr,expr2,operator);}
1370   )*
1371   {return expr;}
1372 }
1373
1374 Expression AdditiveExpression() :
1375 {
1376   Expression expr,expr2;
1377   int operator;
1378 }
1379 {
1380   expr = MultiplicativeExpression()
1381   (
1382    ( <PLUS>  {operator = OperatorIds.PLUS;}
1383    | <MINUS> {operator = OperatorIds.MINUS;} )
1384    expr2 = MultiplicativeExpression()
1385   {expr = new BinaryExpression(expr,expr2,operator);}
1386    )*
1387   {return expr;}
1388 }
1389
1390 Expression MultiplicativeExpression() :
1391 {
1392   Expression expr,expr2;
1393   int operator;
1394 }
1395 {
1396   try {
1397     expr = UnaryExpression()
1398   } catch (ParseException e) {
1399     if (errorMessage != null) throw e;
1400     errorMessage = "unexpected token '"+e.currentToken.next.image+"'";
1401     errorLevel   = ERROR;
1402     errorStart = SimpleCharStream.getPosition() - e.currentToken.next.image.length() + 1;
1403     errorEnd   = SimpleCharStream.getPosition() + 1;
1404     throw e;
1405   }
1406   (
1407    (  <STAR>      {operator = OperatorIds.MULTIPLY;}
1408     | <SLASH>     {operator = OperatorIds.DIVIDE;}
1409     | <REMAINDER> {operator = OperatorIds.REMAINDER;})
1410     expr2 = UnaryExpression()
1411     {expr = new BinaryExpression(expr,expr2,operator);}
1412   )*
1413   {return expr;}
1414 }
1415
1416 /**
1417  * An unary expression starting with @, & or nothing
1418  */
1419 Expression UnaryExpression() :
1420 {
1421   Expression expr;
1422   final int pos = SimpleCharStream.getPosition();
1423 }
1424 {
1425   <BIT_AND> expr = UnaryExpressionNoPrefix()
1426   {return new PrefixedUnaryExpression(expr,OperatorIds.AND,pos);}
1427 |
1428   expr = AtUnaryExpression() {return expr;}
1429 }
1430
1431 Expression AtUnaryExpression() :
1432 {
1433   Expression expr;
1434   final int pos = SimpleCharStream.getPosition();
1435 }
1436 {
1437   <AT>
1438   expr = AtUnaryExpression()
1439   {return new PrefixedUnaryExpression(expr,OperatorIds.AT,pos);}
1440 |
1441   expr = UnaryExpressionNoPrefix()
1442   {return expr;}
1443 }
1444
1445
1446 Expression UnaryExpressionNoPrefix() :
1447 {
1448   Expression expr;
1449   int operator;
1450   final int pos = SimpleCharStream.getPosition();
1451 }
1452 {
1453   (  <PLUS>  {operator = OperatorIds.PLUS;}
1454    | <MINUS> {operator = OperatorIds.MINUS;})
1455    expr = UnaryExpression()
1456   {return new PrefixedUnaryExpression(expr,operator,pos);}
1457 |
1458   expr = PreIncDecExpression()
1459   {return expr;}
1460 |
1461   expr = UnaryExpressionNotPlusMinus()
1462   {return expr;}
1463 }
1464
1465
1466 Expression PreIncDecExpression() :
1467 {
1468 final Expression expr;
1469 final int operator;
1470   final int pos = SimpleCharStream.getPosition();
1471 }
1472 {
1473   (  <PLUS_PLUS> {operator = OperatorIds.PLUS_PLUS;}
1474    | <MINUS_MINUS> {operator = OperatorIds.MINUS_MINUS;})
1475    expr = PrimaryExpression()
1476   {return new PrefixedUnaryExpression(expr,operator,pos);}
1477 }
1478
1479 Expression UnaryExpressionNotPlusMinus() :
1480 {
1481   Expression expr;
1482   final int pos = SimpleCharStream.getPosition();
1483 }
1484 {
1485 //  <BANG> expr = UnaryExpression() {return new PrefixedUnaryExpression(expr,OperatorIds.NOT,pos);}
1486   LOOKAHEAD( <LPAREN> (Type() | <ARRAY>) <RPAREN> )
1487   expr = CastExpression()         {return expr;}
1488 | expr = PostfixExpression()      {return expr;}
1489 | expr = Literal()                {return expr;}
1490 | <LPAREN> expr = Expression()
1491   try {
1492     <RPAREN>
1493   } catch (ParseException e) {
1494     errorMessage = "')' expected";
1495     errorLevel   = ERROR;
1496     errorStart   = SimpleCharStream.getPosition() - e.currentToken.next.image.length() + 1;
1497     errorEnd     = SimpleCharStream.getPosition() + 1;
1498     throw e;
1499   }
1500   {return expr;}
1501 }
1502
1503 CastExpression CastExpression() :
1504 {
1505 final ConstantIdentifier type;
1506 final Expression expr;
1507 final int pos = SimpleCharStream.getPosition();
1508 }
1509 {
1510   <LPAREN>
1511   (type = Type()
1512   | <ARRAY> {type = new ConstantIdentifier(Types.ARRAY,pos,SimpleCharStream.getPosition());})
1513   <RPAREN> expr = UnaryExpression()
1514   {return new CastExpression(type,expr,pos,SimpleCharStream.getPosition());}
1515 }
1516
1517 Expression PostfixExpression() :
1518 {
1519   Expression expr;
1520   int operator = -1;
1521   final int pos = SimpleCharStream.getPosition();
1522 }
1523 {
1524   expr = PrimaryExpression()
1525   [ <PLUS_PLUS> {operator = OperatorIds.PLUS_PLUS;}
1526   | <MINUS_MINUS> {operator = OperatorIds.MINUS_MINUS;}]
1527   {
1528     if (operator == -1) {
1529       return expr;
1530     }
1531     return new PostfixedUnaryExpression(expr,operator,pos);
1532   }
1533 }
1534
1535 Expression PrimaryExpression() :
1536 {
1537   final Token identifier;
1538   Expression expr;
1539   final int pos = SimpleCharStream.getPosition();
1540 }
1541 {
1542   LOOKAHEAD(2)
1543   identifier = <IDENTIFIER> <STATICCLASSACCESS> expr = ClassIdentifier()
1544   {expr = new ClassAccess(new ConstantIdentifier(identifier.image.toCharArray(),
1545                                                  pos,
1546                                                  SimpleCharStream.getPosition()),
1547                           expr,
1548                           ClassAccess.STATIC);}
1549   (
1550   LOOKAHEAD(PrimarySuffix())
1551   expr = PrimarySuffix(expr))*
1552   {return expr;}
1553 |
1554   expr = PrimaryPrefix()
1555   (
1556   LOOKAHEAD(PrimarySuffix())
1557   expr = PrimarySuffix(expr))*
1558   {return expr;}
1559 |
1560   expr = ArrayDeclarator()
1561   {return expr;}
1562 }
1563
1564 /**
1565  * An array declarator.
1566  * array(vars)
1567  * @return an array
1568  */
1569 ArrayInitializer ArrayDeclarator() :
1570 {
1571   final ArrayVariableDeclaration[] vars;
1572   final int pos = SimpleCharStream.getPosition();
1573 }
1574 {
1575   <ARRAY> vars = ArrayInitializer()
1576   {return new ArrayInitializer(vars,pos,SimpleCharStream.getPosition());}
1577 }
1578
1579 Expression PrimaryPrefix() :
1580 {
1581   final Expression expr;
1582   final Token token;
1583   final String var;
1584   final int pos = SimpleCharStream.getPosition();
1585 }
1586 {
1587   token = <IDENTIFIER>           {return new ConstantIdentifier(token.image.toCharArray(),
1588                                                                 pos,
1589                                                                 SimpleCharStream.getPosition());}
1590 | <NEW> expr = ClassIdentifier() {return new PrefixedUnaryExpression(expr,
1591                                                                      OperatorIds.NEW,
1592                                                                      pos);}
1593 | var = VariableDeclaratorId()  {return new VariableDeclaration(currentSegment,
1594                                                                 var.toCharArray(),
1595                                                                 pos,
1596                                                                 SimpleCharStream.getPosition());}
1597 }
1598
1599 PrefixedUnaryExpression classInstantiation() :
1600 {
1601   Expression expr;
1602   final StringBuffer buff;
1603   final int pos = SimpleCharStream.getPosition();
1604 }
1605 {
1606   <NEW> expr = ClassIdentifier()
1607   [
1608     {buff = new StringBuffer(expr.toStringExpression());}
1609     expr = PrimaryExpression()
1610     {buff.append(expr.toStringExpression());
1611     expr = new ConstantIdentifier(buff.toString().toCharArray(),
1612                                   pos,
1613                                   SimpleCharStream.getPosition());}
1614   ]
1615   {return new PrefixedUnaryExpression(expr,
1616                                       OperatorIds.NEW,
1617                                       pos);}
1618 }
1619
1620 ConstantIdentifier ClassIdentifier():
1621 {
1622   final String expr;
1623   final Token token;
1624   final int pos = SimpleCharStream.getPosition();
1625 }
1626 {
1627   token = <IDENTIFIER>          {return new ConstantIdentifier(token.image.toCharArray(),
1628                                                                pos,
1629                                                                SimpleCharStream.getPosition());}
1630 | expr = VariableDeclaratorId() {return new ConstantIdentifier(expr.toCharArray(),
1631                                                                pos,
1632                                                                SimpleCharStream.getPosition());}
1633 }
1634
1635 AbstractSuffixExpression PrimarySuffix(Expression prefix) :
1636 {
1637   final AbstractSuffixExpression expr;
1638 }
1639 {
1640   expr = Arguments(prefix)      {return expr;}
1641 | expr = VariableSuffix(prefix) {return expr;}
1642 }
1643
1644 AbstractSuffixExpression VariableSuffix(Expression prefix) :
1645 {
1646   String expr = null;
1647   final int pos = SimpleCharStream.getPosition();
1648   Expression expression = null;
1649 }
1650 {
1651   <CLASSACCESS>
1652   try {
1653     expr = VariableName()
1654   } catch (ParseException e) {
1655     errorMessage = "unexpected token : '"+ e.currentToken.next.image +"', function call or field access expected";
1656     errorLevel   = ERROR;
1657     errorStart = SimpleCharStream.getPosition() - e.currentToken.next.image.length() + 1;
1658     errorEnd   = SimpleCharStream.getPosition() + 1;
1659     throw e;
1660   }
1661   {return new ClassAccess(prefix,
1662                           new ConstantIdentifier(expr.toCharArray(),pos,SimpleCharStream.getPosition()),
1663                           ClassAccess.NORMAL);}
1664 |
1665   <LBRACKET> [ expression = Expression() | expression = Type() ]  //Not good
1666   try {
1667     <RBRACKET>
1668   } catch (ParseException e) {
1669     errorMessage = "']' expected";
1670     errorLevel   = ERROR;
1671     errorStart = SimpleCharStream.getPosition() - e.currentToken.next.image.length() + 1;
1672     errorEnd   = SimpleCharStream.getPosition() + 1;
1673     throw e;
1674   }
1675   {return new ArrayDeclarator(prefix,expression,SimpleCharStream.getPosition());}
1676 }
1677
1678 Literal Literal() :
1679 {
1680   final Token token;
1681   final int pos;
1682 }
1683 {
1684   token = <INTEGER_LITERAL>        {pos = SimpleCharStream.getPosition();
1685                                     return new NumberLiteral(token.image.toCharArray(),pos-token.image.length(),pos);}
1686 | token = <FLOATING_POINT_LITERAL> {pos = SimpleCharStream.getPosition();
1687                                     return new NumberLiteral(token.image.toCharArray(),pos-token.image.length(),pos);}
1688 | token = <STRING_LITERAL>         {pos = SimpleCharStream.getPosition();
1689                                     return new StringLiteral(token.image.toCharArray(),pos-token.image.length());}
1690 | <TRUE>                           {pos = SimpleCharStream.getPosition();
1691                                     return new TrueLiteral(pos-4,pos);}
1692 | <FALSE>                          {pos = SimpleCharStream.getPosition();
1693                                     return new FalseLiteral(pos-4,pos);}
1694 | <NULL>                           {pos = SimpleCharStream.getPosition();
1695                                     return new NullLiteral(pos-4,pos);}
1696 }
1697
1698 FunctionCall Arguments(Expression func) :
1699 {
1700 Expression[] args = null;
1701 }
1702 {
1703   <LPAREN> [ args = ArgumentList() ]
1704   try {
1705     <RPAREN>
1706   } catch (ParseException e) {
1707     errorMessage = "unexpected token : '"+ e.currentToken.next.image +"', ')' expected to close the argument list";
1708     errorLevel   = ERROR;
1709     errorStart = SimpleCharStream.getPosition() - e.currentToken.next.image.length() + 1;
1710     errorEnd   = SimpleCharStream.getPosition() + 1;
1711     throw e;
1712   }
1713   {return new FunctionCall(func,args,SimpleCharStream.getPosition());}
1714 }
1715
1716 /**
1717  * An argument list is a list of arguments separated by comma :
1718  * argumentDeclaration() (, argumentDeclaration)*
1719  * @return an array of arguments
1720  */
1721 Expression[] ArgumentList() :
1722 {
1723 Expression arg;
1724 final ArrayList list = new ArrayList();
1725 }
1726 {
1727   arg = Expression()
1728   {list.add(arg);}
1729   ( <COMMA>
1730       try {
1731         arg = Expression()
1732         {list.add(arg);}
1733       } catch (ParseException e) {
1734         errorMessage = "unexpected token : '"+ e.currentToken.next.image +"'. An expression expected after a comma in argument list";
1735         errorLevel   = ERROR;
1736         errorStart   = SimpleCharStream.getPosition() - e.currentToken.next.image.length() + 1;
1737         errorEnd     = SimpleCharStream.getPosition() + 1;
1738         throw e;
1739       }
1740    )*
1741    {
1742    Expression[] arguments = new Expression[list.size()];
1743    list.toArray(arguments);
1744    return arguments;}
1745 }
1746
1747 /**
1748  * A Statement without break.
1749  */
1750 Statement StatementNoBreak() :
1751 {
1752   final Statement statement;
1753   Token token = null;
1754 }
1755 {
1756   LOOKAHEAD(2)
1757   statement = Expression()
1758   try {
1759     <SEMICOLON>
1760   } catch (ParseException e) {
1761     if (e.currentToken.next.kind != PHPParserConstants.PHPEND) {
1762       errorMessage = "unexpected token : '"+ e.currentToken.next.image +"'. A ';' was expected";
1763       errorLevel   = ERROR;
1764       errorStart = SimpleCharStream.getPosition() - e.currentToken.next.image.length() + 1;
1765       errorEnd   = SimpleCharStream.getPosition() + 1;
1766       throw e;
1767     }
1768   }
1769   {return statement;}
1770 | LOOKAHEAD(2)
1771   statement = LabeledStatement() {return statement;}
1772 | statement = Block()            {return statement;}
1773 | statement = EmptyStatement()   {return statement;}
1774 | statement = StatementExpression()
1775   try {
1776     <SEMICOLON>
1777   } catch (ParseException e) {
1778     errorMessage = "unexpected token : '"+ e.currentToken.next.image +"'. A ';' was expected";
1779     errorLevel   = ERROR;
1780     errorStart   = SimpleCharStream.getPosition() - e.currentToken.next.image.length() + 1;
1781     errorEnd     = SimpleCharStream.getPosition() + 1;
1782     throw e;
1783   }
1784   {return statement;}
1785 | statement = SwitchStatement()         {return statement;}
1786 | statement = IfStatement()             {return statement;}
1787 | statement = WhileStatement()          {return statement;}
1788 | statement = DoStatement()             {return statement;}
1789 | statement = ForStatement()            {return statement;}
1790 | statement = ForeachStatement()        {return statement;}
1791 | statement = ContinueStatement()       {return statement;}
1792 | statement = ReturnStatement()         {return statement;}
1793 | statement = EchoStatement()           {return statement;}
1794 | [token=<AT>] statement = IncludeStatement()
1795   {if (token != null) {
1796     ((InclusionStatement)statement).silent = true;
1797   }
1798   return statement;}
1799 | statement = StaticStatement()         {return statement;}
1800 | statement = GlobalStatement()         {return statement;}
1801 | statement = defineStatement()         {currentSegment.add((Outlineable)statement);return statement;}
1802 }
1803
1804 Define defineStatement() :
1805 {
1806   final int start = SimpleCharStream.getPosition();
1807   Expression defineName,defineValue;
1808 }
1809 {
1810   <DEFINE>
1811   try {
1812     <LPAREN>
1813   } catch (ParseException e) {
1814     errorMessage = "unexpected token : '"+ e.currentToken.next.image +"', '(' expected";
1815     errorLevel   = ERROR;
1816     errorStart   = SimpleCharStream.getPosition() - e.currentToken.next.image.length() + 1;
1817     errorEnd     = SimpleCharStream.getPosition() + 1;
1818     processParseException(e);
1819   }
1820   try {
1821     defineName = Expression()
1822   } catch (ParseException e) {
1823     errorMessage = "unexpected token : '"+ e.currentToken.next.image +"', expression expected";
1824     errorLevel   = ERROR;
1825     errorStart   = SimpleCharStream.getPosition() - e.currentToken.next.image.length() + 1;
1826     errorEnd     = SimpleCharStream.getPosition() + 1;
1827     throw e;
1828   }
1829   try {
1830     <COMMA>
1831   } catch (ParseException e) {
1832     errorMessage = "unexpected token : '"+ e.currentToken.next.image +"', ',' expected";
1833     errorLevel   = ERROR;
1834     errorStart   = SimpleCharStream.getPosition() - e.currentToken.next.image.length() + 1;
1835     errorEnd     = SimpleCharStream.getPosition() + 1;
1836     processParseException(e);
1837   }
1838   try {
1839     (   defineValue = PrintExpression()
1840       | LOOKAHEAD(varAssignation())
1841         defineValue = varAssignation()
1842       | defineValue = ConditionalExpression())
1843   } catch (ParseException e) {
1844     errorMessage = "unexpected token : '"+ e.currentToken.next.image +"', expression expected";
1845     errorLevel   = ERROR;
1846     errorStart   = SimpleCharStream.getPosition() - e.currentToken.next.image.length() + 1;
1847     errorEnd     = SimpleCharStream.getPosition() + 1;
1848     throw e;
1849   }
1850   try {
1851     <RPAREN>
1852   } catch (ParseException e) {
1853     errorMessage = "unexpected token : '"+ e.currentToken.next.image +"', ')' expected";
1854     errorLevel   = ERROR;
1855     errorStart   = SimpleCharStream.getPosition() - e.currentToken.next.image.length() + 1;
1856     errorEnd     = SimpleCharStream.getPosition() + 1;
1857     processParseException(e);
1858   }
1859   {return new Define(currentSegment,
1860                      defineName,
1861                      defineValue,
1862                      start,
1863                      SimpleCharStream.getPosition());}
1864 }
1865
1866 /**
1867  * A Normal statement.
1868  */
1869 Statement Statement() :
1870 {
1871   final Statement statement;
1872 }
1873 {
1874   statement = StatementNoBreak() {return statement;}
1875 | statement = BreakStatement()   {return statement;}
1876 }
1877
1878 /**
1879  * An html block inside a php syntax.
1880  */
1881 HTMLBlock htmlBlock() :
1882 {
1883   final int startIndex = nodePtr;
1884   AstNode[] blockNodes;
1885   int nbNodes;
1886 }
1887 {
1888   <PHPEND> (phpEchoBlock())*
1889   try {
1890     (<PHPSTARTLONG> | <PHPSTARTSHORT>)
1891   } catch (ParseException e) {
1892     errorMessage = "unexpected end of file , '<?php' expected";
1893     errorLevel   = ERROR;
1894     errorStart   = SimpleCharStream.getPosition();
1895     errorEnd     = SimpleCharStream.getPosition();
1896     throw e;
1897   }
1898   {
1899   nbNodes    = nodePtr - startIndex;
1900   blockNodes = new AstNode[nbNodes];
1901   System.arraycopy(nodes,startIndex,blockNodes,0,nbNodes);
1902   nodePtr = startIndex;
1903   return new HTMLBlock(blockNodes);}
1904 }
1905
1906 /**
1907  * An include statement. It's "include" an expression;
1908  */
1909 InclusionStatement IncludeStatement() :
1910 {
1911   final Expression expr;
1912   final int keyword;
1913   final int pos = SimpleCharStream.getPosition();
1914   final InclusionStatement inclusionStatement;
1915 }
1916 {
1917       (  <REQUIRE>      {keyword = InclusionStatement.REQUIRE;}
1918        | <REQUIRE_ONCE> {keyword = InclusionStatement.REQUIRE_ONCE;}
1919        | <INCLUDE>      {keyword = InclusionStatement.INCLUDE;}
1920        | <INCLUDE_ONCE> {keyword = InclusionStatement.INCLUDE_ONCE;})
1921   try {
1922     expr = Expression()
1923   } catch (ParseException e) {
1924     if (errorMessage != null) {
1925       throw e;
1926     }
1927     errorMessage = "unexpected token '"+ e.currentToken.next.image+"', expression expected";
1928     errorLevel   = ERROR;
1929     errorStart   = SimpleCharStream.getPosition() - e.currentToken.next.image.length() + 1;
1930     errorEnd     = SimpleCharStream.getPosition() + 1;
1931     throw e;
1932   }
1933   {inclusionStatement = new InclusionStatement(currentSegment,
1934                                                keyword,
1935                                                expr,
1936                                                pos);
1937    currentSegment.add(inclusionStatement);
1938   }
1939   try {
1940     <SEMICOLON>
1941   } catch (ParseException e) {
1942     errorMessage = "unexpected token : '"+ e.currentToken.next.image +"'. A ';' was expected";
1943     errorLevel   = ERROR;
1944     errorStart   = SimpleCharStream.getPosition() - e.currentToken.next.image.length() + 1;
1945     errorEnd     = SimpleCharStream.getPosition() + 1;
1946     throw e;
1947   }
1948   {return inclusionStatement;}
1949 }
1950
1951 PrintExpression PrintExpression() :
1952 {
1953   final Expression expr;
1954   final int pos = SimpleCharStream.getPosition();
1955 }
1956 {
1957   <PRINT> expr = Expression() {return new PrintExpression(expr,pos,SimpleCharStream.getPosition());}
1958 }
1959
1960 ListExpression ListExpression() :
1961 {
1962   String expr = null;
1963   Expression expression = null;
1964   ArrayList list = new ArrayList();
1965   final int pos = SimpleCharStream.getPosition();
1966 }
1967 {
1968   <LIST>
1969   try {
1970     <LPAREN>
1971   } catch (ParseException e) {
1972     errorMessage = "unexpected token : '"+ e.currentToken.next.image +"', '(' expected";
1973     errorLevel   = ERROR;
1974     errorStart   = SimpleCharStream.getPosition() - e.currentToken.next.image.length() + 1;
1975     errorEnd     = SimpleCharStream.getPosition() + 1;
1976     throw e;
1977   }
1978   [
1979     expr = VariableDeclaratorId()
1980     {list.add(expr);}
1981   ]
1982   {if (expr == null) list.add(null);}
1983   (
1984     try {
1985       <COMMA>
1986     } catch (ParseException e) {
1987       errorMessage = "unexpected token : '"+ e.currentToken.next.image +"', ',' expected";
1988       errorLevel   = ERROR;
1989       errorStart   = SimpleCharStream.getPosition() - e.currentToken.next.image.length() + 1;
1990       errorEnd     = SimpleCharStream.getPosition() + 1;
1991       throw e;
1992     }
1993     expr = VariableDeclaratorId()
1994     {list.add(expr);}
1995   )*
1996   try {
1997     <RPAREN>
1998   } catch (ParseException e) {
1999     errorMessage = "unexpected token : '"+ e.currentToken.next.image +"', ')' expected";
2000     errorLevel   = ERROR;
2001     errorStart = SimpleCharStream.getPosition() - e.currentToken.next.image.length() + 1;
2002     errorEnd   = SimpleCharStream.getPosition() + 1;
2003     throw e;
2004   }
2005   [ <ASSIGN> expression = Expression()
2006     {
2007     String[] strings = new String[list.size()];
2008     list.toArray(strings);
2009     return new ListExpression(strings,
2010                               expression,
2011                               pos,
2012                               SimpleCharStream.getPosition());}
2013   ]
2014   {
2015     String[] strings = new String[list.size()];
2016     list.toArray(strings);
2017     return new ListExpression(strings,pos,SimpleCharStream.getPosition());}
2018 }
2019
2020 /**
2021  * An echo statement.
2022  * echo anyexpression (, otherexpression)*
2023  */
2024 EchoStatement EchoStatement() :
2025 {
2026   final ArrayList expressions = new ArrayList();
2027   Expression expr;
2028   final int pos = SimpleCharStream.getPosition();
2029 }
2030 {
2031   <ECHO> expr = Expression()
2032   {expressions.add(expr);}
2033   (
2034     <COMMA> expr = Expression()
2035     {expressions.add(expr);}
2036   )*
2037   try {
2038     <SEMICOLON>
2039   } catch (ParseException e) {
2040     if (e.currentToken.next.kind != 4) {
2041       errorMessage = "';' expected after 'echo' statement";
2042       errorLevel   = ERROR;
2043       errorStart   = SimpleCharStream.getPosition() - e.currentToken.next.image.length() + 1;
2044       errorEnd     = SimpleCharStream.getPosition() + 1;
2045       throw e;
2046     }
2047   }
2048   {Expression[] exprs = new Expression[expressions.size()];
2049    expressions.toArray(exprs);
2050    return new EchoStatement(exprs,pos);}
2051 }
2052
2053 GlobalStatement GlobalStatement() :
2054 {
2055    final int pos = SimpleCharStream.getPosition();
2056    String expr;
2057    ArrayList vars = new ArrayList();
2058    GlobalStatement global;
2059 }
2060 {
2061   <GLOBAL>
2062     expr = VariableDeclaratorId()
2063     {vars.add(expr);}
2064   (<COMMA>
2065     expr = VariableDeclaratorId()
2066     {vars.add(expr);}
2067   )*
2068   try {
2069     <SEMICOLON>
2070     {
2071     String[] strings = new String[vars.size()];
2072     vars.toArray(strings);
2073     global = new GlobalStatement(currentSegment,
2074                                  strings,
2075                                  pos,
2076                                  SimpleCharStream.getPosition());
2077     currentSegment.add(global);
2078     return global;}
2079   } catch (ParseException e) {
2080     errorMessage = "unexpected token : '"+ e.currentToken.next.image +"'. a ';' was expected";
2081     errorLevel   = ERROR;
2082     errorStart = SimpleCharStream.getPosition() - e.currentToken.next.image.length() + 1;
2083     errorEnd   = SimpleCharStream.getPosition() + 1;
2084     throw e;
2085   }
2086 }
2087
2088 StaticStatement StaticStatement() :
2089 {
2090   final int pos = SimpleCharStream.getPosition();
2091   final ArrayList vars = new ArrayList();
2092   VariableDeclaration expr;
2093 }
2094 {
2095   <STATIC> expr = VariableDeclarator() {vars.add(new String(expr.name));}
2096   (<COMMA> expr = VariableDeclarator() {vars.add(new String(expr.name));})*
2097   try {
2098     <SEMICOLON>
2099     {
2100     String[] strings = new String[vars.size()];
2101     vars.toArray(strings);
2102     return new StaticStatement(strings,
2103                                 pos,
2104                                 SimpleCharStream.getPosition());}
2105   } catch (ParseException e) {
2106     errorMessage = "unexpected token : '"+ e.currentToken.next.image +"'. a ';' was expected";
2107     errorLevel   = ERROR;
2108     errorStart = SimpleCharStream.getPosition() - e.currentToken.next.image.length() + 1;
2109     errorEnd   = SimpleCharStream.getPosition() + 1;
2110     throw e;
2111   }
2112 }
2113
2114 LabeledStatement LabeledStatement() :
2115 {
2116   final int pos = SimpleCharStream.getPosition();
2117   final Token label;
2118   final Statement statement;
2119 }
2120 {
2121   label = <IDENTIFIER> <COLON> statement = Statement()
2122   {return new LabeledStatement(label.image.toCharArray(),statement,pos,SimpleCharStream.getPosition());}
2123 }
2124
2125 /**
2126  * A Block is
2127  * {
2128  * statements
2129  * }.
2130  * @return a block
2131  */
2132 Block Block() :
2133 {
2134   final int pos = SimpleCharStream.getPosition();
2135   final ArrayList list = new ArrayList();
2136   Statement statement;
2137 }
2138 {
2139   try {
2140     <LBRACE>
2141   } catch (ParseException e) {
2142     errorMessage = "'{' expected";
2143     errorLevel   = ERROR;
2144     errorStart = SimpleCharStream.getPosition() - e.currentToken.next.image.length() + 1;
2145     errorEnd   = SimpleCharStream.getPosition() + 1;
2146     throw e;
2147   }
2148   ( statement = BlockStatement() {list.add(statement);}
2149   | statement = htmlBlock()      {list.add(statement);})*
2150   try {
2151     <RBRACE>
2152   } catch (ParseException e) {
2153     errorMessage = "unexpected token : '"+ e.currentToken.image +"', '}' expected";
2154     errorLevel   = ERROR;
2155     errorStart = SimpleCharStream.getPosition() - e.currentToken.next.image.length() + 1;
2156     errorEnd   = SimpleCharStream.getPosition() + 1;
2157     throw e;
2158   }
2159   {
2160   Statement[] statements = new Statement[list.size()];
2161   list.toArray(statements);
2162   return new Block(statements,pos,SimpleCharStream.getPosition());}
2163 }
2164
2165 Statement BlockStatement() :
2166 {
2167   final Statement statement;
2168 }
2169 {
2170   try {
2171   statement = Statement()         {if (phpDocument == currentSegment) pushOnAstNodes(statement);
2172                                    return statement;}
2173   } catch (ParseException e) {
2174     if (errorMessage != null) throw e;
2175     errorMessage = "statement expected";
2176     errorLevel   = ERROR;
2177     errorStart = SimpleCharStream.getPosition() - e.currentToken.next.image.length() + 1;
2178     errorEnd   = SimpleCharStream.getPosition() + 1;
2179     throw e;
2180   }
2181 | statement = ClassDeclaration()  {return statement;}
2182 | statement = MethodDeclaration() {if (phpDocument == currentSegment) pushOnAstNodes(statement);
2183                                    currentSegment.add((MethodDeclaration) statement);
2184                                    return statement;}
2185 }
2186
2187 /**
2188  * A Block statement that will not contain any 'break'
2189  */
2190 Statement BlockStatementNoBreak() :
2191 {
2192   final Statement statement;
2193 }
2194 {
2195   statement = StatementNoBreak()  {return statement;}
2196 | statement = ClassDeclaration()  {return statement;}
2197 | statement = MethodDeclaration() {currentSegment.add((MethodDeclaration) statement);
2198                                    return statement;}
2199 }
2200
2201 VariableDeclaration[] LocalVariableDeclaration() :
2202 {
2203   final ArrayList list = new ArrayList();
2204   VariableDeclaration var;
2205 }
2206 {
2207   var = LocalVariableDeclarator()
2208   {list.add(var);}
2209   ( <COMMA> var = LocalVariableDeclarator() {list.add(var);})*
2210   {
2211     VariableDeclaration[] vars = new VariableDeclaration[list.size()];
2212     list.toArray(vars);
2213   return vars;}
2214 }
2215
2216 VariableDeclaration LocalVariableDeclarator() :
2217 {
2218   final String varName;
2219   Expression initializer = null;
2220   final int pos = SimpleCharStream.getPosition();
2221 }
2222 {
2223   varName = VariableDeclaratorId() [ <ASSIGN> initializer = Expression() ]
2224   {
2225    if (initializer == null) {
2226     return new VariableDeclaration(currentSegment,
2227                                   varName.toCharArray(),
2228                                   pos,
2229                                   SimpleCharStream.getPosition());
2230    }
2231     return new VariableDeclaration(currentSegment,
2232                                     varName.toCharArray(),
2233                                     initializer,
2234                                     pos);
2235   }
2236 }
2237
2238 EmptyStatement EmptyStatement() :
2239 {
2240   final int pos;
2241 }
2242 {
2243   <SEMICOLON>
2244   {pos = SimpleCharStream.getPosition();
2245    return new EmptyStatement(pos-1,pos);}
2246 }
2247
2248 Expression StatementExpression() :
2249 {
2250   Expression expr,expr2;
2251   int operator;
2252 }
2253 {
2254   expr = PreIncDecExpression() {return expr;}
2255 |
2256   expr = PrimaryExpression()
2257   [ <PLUS_PLUS> {return new PostfixedUnaryExpression(expr,
2258                                                 OperatorIds.PLUS_PLUS,
2259                                                 SimpleCharStream.getPosition());}
2260   | <MINUS_MINUS> {return new PostfixedUnaryExpression(expr,
2261                                                 OperatorIds.MINUS_MINUS,
2262                                                 SimpleCharStream.getPosition());}
2263   | operator = AssignmentOperator() expr2 = Expression()
2264     {return new BinaryExpression(expr,expr2,operator);}
2265   ]
2266   {return expr;}
2267 }
2268
2269 SwitchStatement SwitchStatement() :
2270 {
2271   final Expression variable;
2272   final AbstractCase[] cases;
2273   final int pos = SimpleCharStream.getPosition();
2274 }
2275 {
2276   <SWITCH>
2277   try {
2278     <LPAREN>
2279   } catch (ParseException e) {
2280     errorMessage = "'(' expected after 'switch'";
2281     errorLevel   = ERROR;
2282     errorStart = SimpleCharStream.getPosition() - e.currentToken.next.image.length() + 1;
2283     errorEnd   = SimpleCharStream.getPosition() + 1;
2284     throw e;
2285   }
2286   try {
2287     variable = Expression()
2288   } catch (ParseException e) {
2289     if (errorMessage != null) {
2290       throw e;
2291     }
2292     errorMessage = "expression expected";
2293     errorLevel   = ERROR;
2294     errorStart = SimpleCharStream.getPosition() - e.currentToken.next.image.length() + 1;
2295     errorEnd   = SimpleCharStream.getPosition() + 1;
2296     throw e;
2297   }
2298   try {
2299     <RPAREN>
2300   } catch (ParseException e) {
2301     errorMessage = "')' expected";
2302     errorLevel   = ERROR;
2303     errorStart = SimpleCharStream.getPosition() - e.currentToken.next.image.length() + 1;
2304     errorEnd   = SimpleCharStream.getPosition() + 1;
2305     throw e;
2306   }
2307   (cases = switchStatementBrace() | cases = switchStatementColon(pos, pos + 6))
2308   {return new SwitchStatement(variable,cases,pos,SimpleCharStream.getPosition());}
2309 }
2310
2311 AbstractCase[] switchStatementBrace() :
2312 {
2313   AbstractCase cas;
2314   final ArrayList cases = new ArrayList();
2315 }
2316 {
2317   <LBRACE>
2318  ( cas = switchLabel0() {cases.add(cas);})*
2319   try {
2320     <RBRACE>
2321     {
2322     AbstractCase[] abcase = new AbstractCase[cases.size()];
2323     cases.toArray(abcase);
2324     return abcase;}
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     throw e;
2331   }
2332 }
2333 /**
2334  * A Switch statement with : ... endswitch;
2335  * @param start the begin offset of the switch
2336  * @param end the end offset of the switch
2337  */
2338 AbstractCase[] switchStatementColon(final int start, final int end) :
2339 {
2340   AbstractCase cas;
2341   final ArrayList cases = new ArrayList();
2342 }
2343 {
2344   <COLON>
2345   {try {
2346   setMarker(fileToParse,
2347             "Ugly syntax detected, you should switch () {...} instead of switch (): ... enswitch;",
2348             start,
2349             end,
2350             INFO,
2351             "Line " + token.beginLine);
2352   } catch (CoreException e) {
2353     PHPeclipsePlugin.log(e);
2354   }}
2355   ( cas = switchLabel0() {cases.add(cas);})*
2356   try {
2357     <ENDSWITCH>
2358   } catch (ParseException e) {
2359     errorMessage = "'endswitch' expected";
2360     errorLevel   = ERROR;
2361     errorStart = SimpleCharStream.getPosition() - e.currentToken.next.image.length() + 1;
2362     errorEnd   = SimpleCharStream.getPosition() + 1;
2363     throw e;
2364   }
2365   try {
2366     <SEMICOLON>
2367     {
2368     AbstractCase[] abcase = new AbstractCase[cases.size()];
2369     cases.toArray(abcase);
2370     return abcase;}
2371   } catch (ParseException e) {
2372     errorMessage = "';' expected after 'endswitch' keyword";
2373     errorLevel   = ERROR;
2374     errorStart = SimpleCharStream.getPosition() - e.currentToken.next.image.length() + 1;
2375     errorEnd   = SimpleCharStream.getPosition() + 1;
2376     throw e;
2377   }
2378 }
2379
2380 AbstractCase switchLabel0() :
2381 {
2382   final Expression expr;
2383   Statement statement;
2384   final ArrayList stmts = new ArrayList();
2385   final int pos = SimpleCharStream.getPosition();
2386 }
2387 {
2388   expr = SwitchLabel()
2389   ( statement = BlockStatementNoBreak() {stmts.add(statement);}
2390   | statement = htmlBlock()             {stmts.add(statement);})*
2391   [ statement = BreakStatement()        {stmts.add(statement);}]
2392   {
2393   Statement[] stmtsArray = new Statement[stmts.size()];
2394   stmts.toArray(stmtsArray);
2395   if (expr == null) {//it's a default
2396     return new DefaultCase(stmtsArray,pos,SimpleCharStream.getPosition());
2397   }
2398   return new Case(expr,stmtsArray,pos,SimpleCharStream.getPosition());}
2399 }
2400
2401 /**
2402  * A SwitchLabel.
2403  * case Expression() :
2404  * default :
2405  * @return the if it was a case and null if not
2406  */
2407 Expression SwitchLabel() :
2408 {
2409   final Expression expr;
2410 }
2411 {
2412   token = <CASE>
2413   try {
2414     expr = Expression()
2415   } catch (ParseException e) {
2416     if (errorMessage != null) throw e;
2417     errorMessage = "expression expected after 'case' keyword";
2418     errorLevel   = ERROR;
2419     errorStart = SimpleCharStream.getPosition() - e.currentToken.next.image.length() + 1;
2420     errorEnd   = SimpleCharStream.getPosition() + 1;
2421     throw e;
2422   }
2423   try {
2424     <COLON>
2425     {return expr;}
2426   } catch (ParseException e) {
2427     errorMessage = "':' expected after case expression";
2428     errorLevel   = ERROR;
2429     errorStart = SimpleCharStream.getPosition() - e.currentToken.next.image.length() + 1;
2430     errorEnd   = SimpleCharStream.getPosition() + 1;
2431     throw e;
2432   }
2433 |
2434   token = <_DEFAULT>
2435   try {
2436     <COLON>
2437     {return null;}
2438   } catch (ParseException e) {
2439     errorMessage = "':' expected after 'default' keyword";
2440     errorLevel   = ERROR;
2441     errorStart = SimpleCharStream.getPosition() - e.currentToken.next.image.length() + 1;
2442     errorEnd   = SimpleCharStream.getPosition() + 1;
2443     throw e;
2444   }
2445 }
2446
2447 Break BreakStatement() :
2448 {
2449   Expression expression = null;
2450   final int start = SimpleCharStream.getPosition();
2451 }
2452 {
2453   <BREAK> [ expression = Expression() ]
2454   try {
2455     <SEMICOLON>
2456   } catch (ParseException e) {
2457     errorMessage = "';' expected after 'break' keyword";
2458     errorLevel   = ERROR;
2459     errorStart = SimpleCharStream.getPosition() - e.currentToken.next.image.length() + 1;
2460     errorEnd   = SimpleCharStream.getPosition() + 1;
2461     throw e;
2462   }
2463   {return new Break(expression, start, SimpleCharStream.getPosition());}
2464 }
2465
2466 IfStatement IfStatement() :
2467 {
2468   final int pos = SimpleCharStream.getPosition();
2469   Expression condition;
2470   IfStatement ifStatement;
2471 }
2472 {
2473   <IF> condition = Condition("if") ifStatement = IfStatement0(condition, pos,pos+2)
2474   {return ifStatement;}
2475 }
2476
2477
2478 Expression Condition(final String keyword) :
2479 {
2480   final Expression condition;
2481 }
2482 {
2483   try {
2484     <LPAREN>
2485   } catch (ParseException e) {
2486     errorMessage = "'(' expected after " + keyword + " keyword";
2487     errorLevel   = ERROR;
2488     errorStart = SimpleCharStream.getPosition() - e.currentToken.next.image.length();
2489     errorEnd   = errorStart +1;
2490     processParseException(e);
2491   }
2492   condition = Expression()
2493   try {
2494      <RPAREN>
2495   } catch (ParseException e) {
2496     errorMessage = "')' expected after " + keyword + " keyword";
2497     errorLevel   = ERROR;
2498     errorStart = SimpleCharStream.getPosition() - e.currentToken.next.image.length() + 1;
2499     errorEnd   = SimpleCharStream.getPosition() + 1;
2500     processParseException(e);
2501   }
2502   {return condition;}
2503 }
2504
2505 IfStatement IfStatement0(Expression condition, final int start,final int end) :
2506 {
2507   Statement statement;
2508   Statement stmt;
2509   final Statement[] statementsArray;
2510   ElseIf elseifStatement;
2511   Else elseStatement = null;
2512   ArrayList stmts;
2513   final ArrayList elseIfList = new ArrayList();
2514   ElseIf[] elseIfs;
2515   int pos = SimpleCharStream.getPosition();
2516   int endStatements;
2517 }
2518 {
2519   <COLON>
2520   {stmts = new ArrayList();}
2521   (  statement = Statement() {stmts.add(statement);}
2522    | statement = htmlBlock() {stmts.add(statement);})*
2523    {endStatements = SimpleCharStream.getPosition();}
2524    (elseifStatement = ElseIfStatementColon() {elseIfList.add(elseifStatement);})*
2525    [elseStatement = ElseStatementColon()]
2526
2527   {try {
2528   setMarker(fileToParse,
2529             "Ugly syntax detected, you should if () {...} instead of if (): ... endif;",
2530             start,
2531             end,
2532             INFO,
2533             "Line " + token.beginLine);
2534   } catch (CoreException e) {
2535     PHPeclipsePlugin.log(e);
2536   }}
2537   try {
2538     <ENDIF>
2539   } catch (ParseException e) {
2540     errorMessage = "'endif' expected";
2541     errorLevel   = ERROR;
2542     errorStart = SimpleCharStream.getPosition() - e.currentToken.next.image.length() + 1;
2543     errorEnd   = SimpleCharStream.getPosition() + 1;
2544     throw e;
2545   }
2546   try {
2547     <SEMICOLON>
2548   } catch (ParseException e) {
2549     errorMessage = "';' expected after 'endif' keyword";
2550     errorLevel   = ERROR;
2551     errorStart = SimpleCharStream.getPosition() - e.currentToken.next.image.length() + 1;
2552     errorEnd   = SimpleCharStream.getPosition() + 1;
2553     throw e;
2554   }
2555     {
2556     elseIfs = new ElseIf[elseIfList.size()];
2557     elseIfList.toArray(elseIfs);
2558     if (stmts.size() == 1) {
2559       return new IfStatement(condition,
2560                              (Statement) stmts.get(0),
2561                               elseIfs,
2562                               elseStatement,
2563                               pos,
2564                               SimpleCharStream.getPosition());
2565     } else {
2566       statementsArray = new Statement[stmts.size()];
2567       stmts.toArray(statementsArray);
2568       return new IfStatement(condition,
2569                              new Block(statementsArray,pos,endStatements),
2570                              elseIfs,
2571                              elseStatement,
2572                              pos,
2573                              SimpleCharStream.getPosition());
2574     }
2575     }
2576
2577 |
2578   (stmt = Statement() | stmt = htmlBlock())
2579   ( LOOKAHEAD(1) elseifStatement = ElseIfStatement() {elseIfList.add(elseifStatement);})*
2580   [ LOOKAHEAD(1)
2581     <ELSE>
2582     try {
2583       {pos = SimpleCharStream.getPosition();}
2584       statement = Statement()
2585       {elseStatement = new Else(statement,pos,SimpleCharStream.getPosition());}
2586     } catch (ParseException e) {
2587       if (errorMessage != null) {
2588         throw e;
2589       }
2590       errorMessage = "unexpected token '"+e.currentToken.next.image+"', a statement was expected";
2591       errorLevel   = ERROR;
2592       errorStart = SimpleCharStream.getPosition() - e.currentToken.next.image.length() + 1;
2593       errorEnd   = SimpleCharStream.getPosition() + 1;
2594       throw e;
2595     }
2596   ]
2597   {
2598     elseIfs = new ElseIf[elseIfList.size()];
2599     elseIfList.toArray(elseIfs);
2600     return new IfStatement(condition,
2601                            stmt,
2602                            elseIfs,
2603                            elseStatement,
2604                            pos,
2605                            SimpleCharStream.getPosition());}
2606 }
2607
2608 ElseIf ElseIfStatementColon() :
2609 {
2610   Expression condition;
2611   Statement statement;
2612   final ArrayList list = new ArrayList();
2613   final int pos = SimpleCharStream.getPosition();
2614 }
2615 {
2616   <ELSEIF> condition = Condition("elseif")
2617   <COLON> (  statement = Statement() {list.add(statement);}
2618            | statement = htmlBlock() {list.add(statement);})*
2619   {
2620   Statement[] stmtsArray = new Statement[list.size()];
2621   list.toArray(stmtsArray);
2622   return new ElseIf(condition,stmtsArray ,pos,SimpleCharStream.getPosition());}
2623 }
2624
2625 Else ElseStatementColon() :
2626 {
2627   Statement statement;
2628   final ArrayList list = new ArrayList();
2629   final int pos = SimpleCharStream.getPosition();
2630 }
2631 {
2632   <ELSE> <COLON> (  statement = Statement() {list.add(statement);}
2633                   | statement = htmlBlock() {list.add(statement);})*
2634   {
2635   Statement[] stmtsArray = new Statement[list.size()];
2636   list.toArray(stmtsArray);
2637   return new Else(stmtsArray,pos,SimpleCharStream.getPosition());}
2638 }
2639
2640 ElseIf ElseIfStatement() :
2641 {
2642   Expression condition;
2643   Statement statement;
2644   final ArrayList list = new ArrayList();
2645   final int pos = SimpleCharStream.getPosition();
2646 }
2647 {
2648   <ELSEIF> condition = Condition("elseif") statement = Statement() {list.add(statement);/*todo:do better*/}
2649   {
2650   Statement[] stmtsArray = new Statement[list.size()];
2651   list.toArray(stmtsArray);
2652   return new ElseIf(condition,stmtsArray,pos,SimpleCharStream.getPosition());}
2653 }
2654
2655 WhileStatement WhileStatement() :
2656 {
2657   final Expression condition;
2658   final Statement action;
2659   final int pos = SimpleCharStream.getPosition();
2660 }
2661 {
2662   <WHILE>
2663     condition = Condition("while")
2664     action    = WhileStatement0(pos,pos + 5)
2665     {return new WhileStatement(condition,action,pos,SimpleCharStream.getPosition());}
2666 }
2667
2668 Statement WhileStatement0(final int start, final int end) :
2669 {
2670   Statement statement;
2671   final ArrayList stmts = new ArrayList();
2672   final int pos = SimpleCharStream.getPosition();
2673 }
2674 {
2675   <COLON> (statement = Statement() {stmts.add(statement);})*
2676   {try {
2677   setMarker(fileToParse,
2678             "Ugly syntax detected, you should while () {...} instead of while (): ... endwhile;",
2679             start,
2680             end,
2681             INFO,
2682             "Line " + token.beginLine);
2683   } catch (CoreException e) {
2684     PHPeclipsePlugin.log(e);
2685   }}
2686   try {
2687     <ENDWHILE>
2688   } catch (ParseException e) {
2689     errorMessage = "'endwhile' expected";
2690     errorLevel   = ERROR;
2691     errorStart = SimpleCharStream.getPosition() - e.currentToken.next.image.length() + 1;
2692     errorEnd   = SimpleCharStream.getPosition() + 1;
2693     throw e;
2694   }
2695   try {
2696     <SEMICOLON>
2697     {
2698     Statement[] stmtsArray = new Statement[stmts.size()];
2699     stmts.toArray(stmtsArray);
2700     return new Block(stmtsArray,pos,SimpleCharStream.getPosition());}
2701   } catch (ParseException e) {
2702     errorMessage = "';' expected after 'endwhile' keyword";
2703     errorLevel   = ERROR;
2704     errorStart = SimpleCharStream.getPosition() - e.currentToken.next.image.length() + 1;
2705     errorEnd   = SimpleCharStream.getPosition() + 1;
2706     throw e;
2707   }
2708 |
2709   statement = Statement()
2710   {return statement;}
2711 }
2712
2713 DoStatement DoStatement() :
2714 {
2715   final Statement action;
2716   final Expression condition;
2717   final int pos = SimpleCharStream.getPosition();
2718 }
2719 {
2720   <DO> action = Statement() <WHILE> condition = Condition("while")
2721   try {
2722     <SEMICOLON>
2723     {return new DoStatement(condition,action,pos,SimpleCharStream.getPosition());}
2724   } catch (ParseException e) {
2725     errorMessage = "unexpected token : '"+ e.currentToken.next.image +"'. A ';' was expected";
2726     errorLevel   = ERROR;
2727     errorStart = SimpleCharStream.getPosition() - e.currentToken.next.image.length() + 1;
2728     errorEnd   = SimpleCharStream.getPosition() + 1;
2729     throw e;
2730   }
2731 }
2732
2733 ForeachStatement ForeachStatement() :
2734 {
2735   Statement statement;
2736   Expression expression;
2737   final int pos = SimpleCharStream.getPosition();
2738   ArrayVariableDeclaration variable;
2739 }
2740 {
2741   <FOREACH>
2742     try {
2743     <LPAREN>
2744   } catch (ParseException e) {
2745     errorMessage = "'(' expected after 'foreach' keyword";
2746     errorLevel   = ERROR;
2747     errorStart = SimpleCharStream.getPosition() - e.currentToken.next.image.length() + 1;
2748     errorEnd   = SimpleCharStream.getPosition() + 1;
2749     throw e;
2750   }
2751   try {
2752     expression = Expression()
2753   } catch (ParseException e) {
2754     errorMessage = "variable expected";
2755     errorLevel   = ERROR;
2756     errorStart = SimpleCharStream.getPosition() - e.currentToken.next.image.length() + 1;
2757     errorEnd   = SimpleCharStream.getPosition() + 1;
2758     throw e;
2759   }
2760   try {
2761     <AS>
2762   } catch (ParseException e) {
2763     errorMessage = "'as' expected";
2764     errorLevel   = ERROR;
2765     errorStart = SimpleCharStream.getPosition() - e.currentToken.next.image.length() + 1;
2766     errorEnd   = SimpleCharStream.getPosition() + 1;
2767     throw e;
2768   }
2769   try {
2770     variable = ArrayVariable()
2771   } catch (ParseException e) {
2772     errorMessage = "variable expected";
2773     errorLevel   = ERROR;
2774     errorStart = SimpleCharStream.getPosition() - e.currentToken.next.image.length() + 1;
2775     errorEnd   = SimpleCharStream.getPosition() + 1;
2776     throw e;
2777   }
2778   try {
2779     <RPAREN>
2780   } catch (ParseException e) {
2781     errorMessage = "')' expected after 'foreach' keyword";
2782     errorLevel   = ERROR;
2783     errorStart = SimpleCharStream.getPosition() - e.currentToken.next.image.length() + 1;
2784     errorEnd   = SimpleCharStream.getPosition() + 1;
2785     throw e;
2786   }
2787   try {
2788     statement = Statement()
2789   } catch (ParseException e) {
2790     if (errorMessage != null) throw e;
2791     errorMessage = "statement expected";
2792     errorLevel   = ERROR;
2793     errorStart = SimpleCharStream.getPosition() - e.currentToken.next.image.length() + 1;
2794     errorEnd   = SimpleCharStream.getPosition() + 1;
2795     throw e;
2796   }
2797   {return new ForeachStatement(expression,
2798                                variable,
2799                                statement,
2800                                pos,
2801                                SimpleCharStream.getPosition());}
2802
2803 }
2804
2805 ForStatement ForStatement() :
2806 {
2807 final Token token;
2808 final int pos = SimpleCharStream.getPosition();
2809 Expression[] initializations = null;
2810 Expression condition = null;
2811 Expression[] increments = null;
2812 Statement action;
2813 final ArrayList list = new ArrayList();
2814 final int startBlock, endBlock;
2815 }
2816 {
2817   token = <FOR>
2818   try {
2819     <LPAREN>
2820   } catch (ParseException e) {
2821     errorMessage = "'(' expected after 'for' keyword";
2822     errorLevel   = ERROR;
2823     errorStart = SimpleCharStream.getPosition() - e.currentToken.next.image.length() + 1;
2824     errorEnd   = SimpleCharStream.getPosition() + 1;
2825     throw e;
2826   }
2827      [ initializations = ForInit() ] <SEMICOLON>
2828      [ condition = Expression() ] <SEMICOLON>
2829      [ increments = StatementExpressionList() ] <RPAREN>
2830     (
2831       action = Statement()
2832       {return new ForStatement(initializations,condition,increments,action,pos,SimpleCharStream.getPosition());}
2833     |
2834       <COLON>
2835       {startBlock = SimpleCharStream.getPosition();}
2836       (action = Statement() {list.add(action);})*
2837       {
2838         try {
2839         setMarker(fileToParse,
2840                   "Ugly syntax detected, you should for () {...} instead of for (): ... endfor;",
2841                   pos,
2842                   pos+token.image.length(),
2843                   INFO,
2844                   "Line " + token.beginLine);
2845         } catch (CoreException e) {
2846           PHPeclipsePlugin.log(e);
2847         }
2848       }
2849       {endBlock = SimpleCharStream.getPosition();}
2850       try {
2851         <ENDFOR>
2852       } catch (ParseException e) {
2853         errorMessage = "'endfor' expected";
2854         errorLevel   = ERROR;
2855         errorStart = SimpleCharStream.getPosition() - e.currentToken.next.image.length() + 1;
2856         errorEnd   = SimpleCharStream.getPosition() + 1;
2857         throw e;
2858       }
2859       try {
2860         <SEMICOLON>
2861         {
2862         Statement[] stmtsArray = new Statement[list.size()];
2863         list.toArray(stmtsArray);
2864         return new ForStatement(initializations,condition,increments,new Block(stmtsArray,startBlock,endBlock),pos,SimpleCharStream.getPosition());}
2865       } catch (ParseException e) {
2866         errorMessage = "';' expected after 'endfor' keyword";
2867         errorLevel   = ERROR;
2868         errorStart = SimpleCharStream.getPosition() - e.currentToken.next.image.length() + 1;
2869         errorEnd   = SimpleCharStream.getPosition() + 1;
2870         throw e;
2871       }
2872     )
2873 }
2874
2875 Expression[] ForInit() :
2876 {
2877   Expression[] exprs;
2878 }
2879 {
2880   LOOKAHEAD(LocalVariableDeclaration())
2881   exprs = LocalVariableDeclaration()
2882   {return exprs;}
2883 |
2884   exprs = StatementExpressionList()
2885   {return exprs;}
2886 }
2887
2888 Expression[] StatementExpressionList() :
2889 {
2890   final ArrayList list = new ArrayList();
2891   Expression expr;
2892 }
2893 {
2894   expr = StatementExpression()   {list.add(expr);}
2895   (<COMMA> StatementExpression() {list.add(expr);})*
2896   {
2897   Expression[] exprsArray = new Expression[list.size()];
2898   list.toArray(exprsArray);
2899   return exprsArray;}
2900 }
2901
2902 Continue ContinueStatement() :
2903 {
2904   Expression expr = null;
2905   final int pos = SimpleCharStream.getPosition();
2906 }
2907 {
2908   <CONTINUE> [ expr = Expression() ]
2909   try {
2910     <SEMICOLON>
2911     {return new Continue(expr,pos,SimpleCharStream.getPosition());}
2912   } catch (ParseException e) {
2913     errorMessage = "';' expected after 'continue' statement";
2914     errorLevel   = ERROR;
2915     errorStart = SimpleCharStream.getPosition() - e.currentToken.next.image.length() + 1;
2916     errorEnd   = SimpleCharStream.getPosition() + 1;
2917     throw e;
2918   }
2919 }
2920
2921 ReturnStatement ReturnStatement() :
2922 {
2923   Expression expr = null;
2924   final int pos = SimpleCharStream.getPosition();
2925 }
2926 {
2927   <RETURN> [ expr = Expression() ]
2928   try {
2929     <SEMICOLON>
2930     {return new ReturnStatement(expr,pos,SimpleCharStream.getPosition());}
2931   } catch (ParseException e) {
2932     errorMessage = "';' expected after 'return' statement";
2933     errorLevel   = ERROR;
2934     errorStart = SimpleCharStream.getPosition() - e.currentToken.next.image.length() + 1;
2935     errorEnd   = SimpleCharStream.getPosition() + 1;
2936     throw e;
2937   }
2938 }