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

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