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

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