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