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

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