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