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