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

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