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