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

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