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

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