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 class PHPParser extends PHPParserSuperclass {
  52
  53   private static IFile fileToParse;
  54
  55   /** The current segment */
  56   private static PHPSegmentWithChildren currentSegment;
  57
  58   private static final String PARSE_ERROR_STRING = "Parse error"; //$NON-NLS-1$
  59   private static final String PARSE_WARNING_STRING = "Warning"; //$NON-NLS-1$
  60   PHPOutlineInfo outlineInfo;
  61   private static int errorLevel = ERROR;
  62   private static String errorMessage;
  63
  64   public PHPParser() {
  65   }
  66
  67   public void setFileToParse(IFile fileToParse) {
  68     this.fileToParse = fileToParse;
  69   }
  70
  71   public PHPParser(IFile fileToParse) {
  72     this(new StringReader(""));
  73     this.fileToParse = fileToParse;
  74   }
  75
  76   public void phpParserTester(String strEval) throws CoreException, ParseException {
  77     PHPParserTokenManager.SwitchTo(PHPParserTokenManager.PHPPARSING);
  78     StringReader stream = new StringReader(strEval);
  79     if (jj_input_stream == null) {
  80       jj_input_stream = new SimpleCharStream(stream, 1, 1);
  81     }
  82     ReInit(new StringReader(strEval));
  83     phpTest();
  84   }
  85
  86   public void htmlParserTester(String strEval) throws CoreException, ParseException {
  87     StringReader stream = new StringReader(strEval);
  88     if (jj_input_stream == null) {
  89       jj_input_stream = new SimpleCharStream(stream, 1, 1);
  90     }
  91     ReInit(stream);
  92     phpFile();
  93   }
  94
  95   public PHPOutlineInfo parseInfo(Object parent, String s) {
  96     outlineInfo = new PHPOutlineInfo(parent);
  97     currentSegment = outlineInfo.getDeclarations();
  98     StringReader stream = new StringReader(s);
  99     if (jj_input_stream == null) {
 100       jj_input_stream = new SimpleCharStream(stream, 1, 1);
 101     }
 102     ReInit(stream);
 103     try {
 104       parse();
 105     } catch (ParseException e) {
 106       processParseException(e);
 107     }
 108     return outlineInfo;
 109   }
 110
 111   /**
 112    * This method will process the parse exception.
 113    * If the error message is null, the parse exception wasn't catched and a trace is written in the log
 114    * @param e the ParseException
 115    */
 116   private static void processParseException(final ParseException e) {
 117     if (errorMessage == null) {
 118       PHPeclipsePlugin.log(e);
 119       errorMessage = "this exception wasn't handled by the parser please tell us how to reproduce it";
 120     }
 121     setMarker(e);
 122     errorMessage = null;
 123   }
 124
 125   /**
 126    * Create marker for the parse error
 127    */
 128   private static void setMarker(ParseException e) {
 129     try {
 130       setMarker(fileToParse,
 131                 errorMessage,
 132                 jj_input_stream.tokenBegin,
 133                 jj_input_stream.tokenBegin + e.currentToken.image.length(),
 134                 errorLevel,
 135                 "Line " + e.currentToken.beginLine);
 136     } catch (CoreException e2) {
 137       PHPeclipsePlugin.log(e2);
 138     }
 139   }
 140
 141   /**
 142    * Create markers according to the external parser output
 143    */
 144   private static void createMarkers(String output, IFile file) throws CoreException {
 145     // delete all markers
 146     file.deleteMarkers(IMarker.PROBLEM, false, 0);
 147
 148     int indx = 0;
 149     int brIndx = 0;
 150     boolean flag = true;
 151     while ((brIndx = output.indexOf("<br />", indx)) != -1) {
 152       // newer php error output (tested with 4.2.3)
 153       scanLine(output, file, indx, brIndx);
 154       indx = brIndx + 6;
 155       flag = false;
 156     }
 157     if (flag) {
 158       while ((brIndx = output.indexOf("<br>", indx)) != -1) {
 159         // older php error output (tested with 4.2.3)
 160         scanLine(output, file, indx, brIndx);
 161         indx = brIndx + 4;
 162       }
 163     }
 164   }
 165
 166   private static void scanLine(String output, IFile file, int indx, int brIndx) throws CoreException {
 167     String current;
 168     StringBuffer lineNumberBuffer = new StringBuffer(10);
 169     char ch;
 170     current = output.substring(indx, brIndx);
 171
 172     if (current.indexOf(PARSE_WARNING_STRING) != -1 || current.indexOf(PARSE_ERROR_STRING) != -1) {
 173       int onLine = current.indexOf("on line <b>");
 174       if (onLine != -1) {
 175         lineNumberBuffer.delete(0, lineNumberBuffer.length());
 176         for (int i = onLine; i < current.length(); i++) {
 177           ch = current.charAt(i);
 178           if ('0' <= ch && '9' >= ch) {
 179             lineNumberBuffer.append(ch);
 180           }
 181         }
 182
 183         int lineNumber = Integer.parseInt(lineNumberBuffer.toString());
 184
 185         Hashtable attributes = new Hashtable();
 186
 187         current = current.replaceAll("\n", "");
 188         current = current.replaceAll("<b>", "");
 189         current = current.replaceAll("</b>", "");
 190         MarkerUtilities.setMessage(attributes, current);
 191
 192         if (current.indexOf(PARSE_ERROR_STRING) != -1)
 193           attributes.put(IMarker.SEVERITY, new Integer(IMarker.SEVERITY_ERROR));
 194         else if (current.indexOf(PARSE_WARNING_STRING) != -1)
 195           attributes.put(IMarker.SEVERITY, new Integer(IMarker.SEVERITY_WARNING));
 196         else
 197           attributes.put(IMarker.SEVERITY, new Integer(IMarker.SEVERITY_INFO));
 198         MarkerUtilities.setLineNumber(attributes, lineNumber);
 199         MarkerUtilities.createMarker(file, attributes, IMarker.PROBLEM);
 200       }
 201     }
 202   }
 203
 204   public void parse(String s) throws CoreException {
 205     ReInit(new StringReader(s));
 206     try {
 207       parse();
 208     } catch (ParseException e) {
 209       processParseException(e);
 210     }
 211   }
 212
 213   /**
 214    * Call the php parse command ( php -l -f &lt;filename&gt; )
 215    * and create markers according to the external parser output
 216    */
 217   public static void phpExternalParse(IFile file) {
 218     IPreferenceStore store = PHPeclipsePlugin.getDefault().getPreferenceStore();
 219     String filename = file.getLocation().toString();
 220
 221     String[] arguments = { filename };
 222     MessageFormat form = new MessageFormat(store.getString(PHPeclipsePlugin.EXTERNAL_PARSER_PREF));
 223     String command = form.format(arguments);
 224
 225     String parserResult = PHPStartApacheAction.getParserOutput(command, "External parser: ");
 226
 227     try {
 228       // parse the buffer to find the errors and warnings
 229       createMarkers(parserResult, file);
 230     } catch (CoreException e) {
 231       PHPeclipsePlugin.log(e);
 232     }
 233   }
 234
 235   public void parse() throws ParseException {
 236           phpFile();
 237   }
 238 }
 239
 240 PARSER_END(PHPParser)
 241
 242 <DEFAULT> TOKEN :
 243 {
 244   <PHPSTART : "<?php" | "<?"> : PHPPARSING
 245 }
 246
 247 <PHPPARSING> TOKEN :
 248 {
 249   <PHPEND :"?>"> : DEFAULT
 250 }
 251
 252 <DEFAULT> SKIP :
 253 {
 254  < ~[] >
 255 }
 256
 257
 258 /* WHITE SPACE */
 259
 260 <PHPPARSING> SKIP :
 261 {
 262   " "
 263 | "\t"
 264 | "\n"
 265 | "\r"
 266 | "\f"
 267 }
 268
 269 /* COMMENTS */
 270
 271 <PHPPARSING> MORE :
 272 {
 273   "//" : IN_SINGLE_LINE_COMMENT
 274 |
 275   <"/**" ~["/"]> { input_stream.backup(1); } : IN_FORMAL_COMMENT
 276 |
 277   "/*" : IN_MULTI_LINE_COMMENT
 278 }
 279
 280 <IN_SINGLE_LINE_COMMENT> SPECIAL_TOKEN :
 281 {
 282   <SINGLE_LINE_COMMENT: "\n" | "\r" | "\r\n" > : PHPPARSING
 283 }
 284
 285 <IN_SINGLE_LINE_COMMENT> TOKEN :
 286 {
 287   <SINGLE_LINE_COMMENT_PHPEND : "?>" > : DEFAULT
 288 }
 289
 290 <IN_FORMAL_COMMENT>
 291 SPECIAL_TOKEN :
 292 {
 293   <FORMAL_COMMENT: "*/" > : PHPPARSING
 294 }
 295
 296 <IN_MULTI_LINE_COMMENT>
 297 SPECIAL_TOKEN :
 298 {
 299   <MULTI_LINE_COMMENT: "*/" > : PHPPARSING
 300 }
 301
 302 <IN_SINGLE_LINE_COMMENT,IN_FORMAL_COMMENT,IN_MULTI_LINE_COMMENT>
 303 MORE :
 304 {
 305   < ~[] >
 306 }
 307
 308 /* KEYWORDS */
 309 <PHPPARSING> TOKEN :
 310 {
 311   <CLASS    : "class">
 312 | <FUNCTION : "function">
 313 | <VAR      : "var">
 314 | <IF       : "if">
 315 | <ELSEIF   : "elseif">
 316 | <ELSE     : "else">
 317 | <ARRAY    : "array">
 318 }
 319
 320 /* LANGUAGE CONSTRUCT */
 321 <PHPPARSING> TOKEN :
 322 {
 323   <PRINT : "print">
 324 | <ECHO : "echo">
 325 | <INCLUDE : "include">
 326 | <REQUIRE : "require">
 327 | <INCLUDE_ONCE : "include_once">
 328 | <REQUIRE_ONCE : "require_once">
 329 | <GLOBAL : "global">
 330 | <STATIC : "static">
 331 | <CLASSACCESS: "->">
 332 | <STATICCLASSACCESS: "::">
 333 | <ARRAYASSIGN: "=>">
 334 }
 335
 336 /* RESERVED WORDS AND LITERALS */
 337
 338 <PHPPARSING> TOKEN :
 339 {
 340   < BREAK: "break" >
 341 | < CASE: "case" >
 342 | < CONST: "const" >
 343 | < CONTINUE: "continue" >
 344 | < _DEFAULT: "default" >
 345 | < DO: "do" >
 346 | < EXTENDS: "extends" >
 347 | < FALSE: "false" >
 348 | < FOR: "for" >
 349 | < GOTO: "goto" >
 350 | < NEW: "new" >
 351 | < NULL: "null" >
 352 | < RETURN: "return" >
 353 | < SUPER: "super" >
 354 | < SWITCH: "switch" >
 355 | < THIS: "this" >
 356 | < TRUE: "true" >
 357 | < WHILE: "while" >
 358 | < ENDWHILE : "endwhile" >
 359 | <FOREACH : "foreach" >
 360 | <AS : "as" >
 361 }
 362
 363 /* TYPES */
 364
 365 <PHPPARSING> TOKEN :
 366 {
 367   <STRING : "string">
 368 | <OBJECT : "object">
 369 | <BOOL : "bool">
 370 | <BOOLEAN : "boolean">
 371 | <REAL : "real">
 372 | <DOUBLE : "double">
 373 | <FLOAT : "float">
 374 | <INT : "int">
 375 | <INTEGER : "integer">
 376 }
 377
 378 <PHPPARSING> TOKEN :
 379 {
 380   < _ORL : "OR" >
 381 | < _ANDL: "AND">
 382 }
 383
 384 /* LITERALS */
 385
 386 <PHPPARSING> TOKEN :
 387 {
 388   < INTEGER_LITERAL:
 389         <DECIMAL_LITERAL> (["l","L"])?
 390       | <HEX_LITERAL> (["l","L"])?
 391       | <OCTAL_LITERAL> (["l","L"])?
 392   >
 393 |
 394   < #DECIMAL_LITERAL: ["1"-"9"] (["0"-"9"])* >
 395 |
 396   < #HEX_LITERAL: "0" ["x","X"] (["0"-"9","a"-"f","A"-"F"])+ >
 397 |
 398   < #OCTAL_LITERAL: "0" (["0"-"7"])* >
 399 |
 400   < FLOATING_POINT_LITERAL:
 401         (["0"-"9"])+ "." (["0"-"9"])* (<EXPONENT>)? (["f","F","d","D"])?
 402       | "." (["0"-"9"])+ (<EXPONENT>)? (["f","F","d","D"])?
 403       | (["0"-"9"])+ <EXPONENT> (["f","F","d","D"])?
 404       | (["0"-"9"])+ (<EXPONENT>)? ["f","F","d","D"]
 405   >
 406 |
 407   < #EXPONENT: ["e","E"] (["+","-"])? (["0"-"9"])+ >
 408 |
 409   < STRING_LITERAL: (<STRING_1> | <STRING_2> | <STRING_3>)>
 410 |    < STRING_1:
 411       "\""
 412       (
 413         ~["\""]
 414         |
 415         "\\\""
 416       )*
 417       "\""
 418     >
 419 |    < STRING_2:
 420       "'"
 421       (
 422       ~["'"]
 423        |
 424        "\\'"
 425       )*
 426
 427       "'"
 428     >
 429 |   < STRING_3:
 430       "`"
 431       (
 432         ~["`"]
 433       |
 434         "\\`"
 435       )*
 436       "`"
 437     >
 438 }
 439
 440 /* IDENTIFIERS */
 441
 442 <PHPPARSING> TOKEN :
 443 {
 444   < IDENTIFIER: (<LETTER>|<SPECIAL>) (<LETTER>|<DIGIT>|<SPECIAL>)* >
 445 |
 446   < #LETTER:
 447       ["a"-"z"] | ["A"-"Z"]
 448   >
 449 |
 450   < #DIGIT:
 451       ["0"-"9"]
 452   >
 453 |
 454   < #SPECIAL:
 455     "_" | ["\u007f"-"\u00ff"]
 456   >
 457 }
 458
 459 /* SEPARATORS */
 460
 461 <PHPPARSING> TOKEN :
 462 {
 463   < LPAREN: "(" >
 464 | < RPAREN: ")" >
 465 | < LBRACE: "{" >
 466 | < RBRACE: "}" >
 467 | < LBRACKET: "[" >
 468 | < RBRACKET: "]" >
 469 | < SEMICOLON: ";" >
 470 | < COMMA: "," >
 471 | < DOT: "." >
 472 }
 473
 474 /* OPERATORS */
 475
 476 <PHPPARSING> TOKEN :
 477 {
 478   <AT     : "@">
 479 | <DOLLAR : "$">
 480 | <ASSIGN: "=" >
 481 | <GT: ">" >
 482 | <LT: "<" >
 483 | <BANG: "!" >
 484 | <HOOK: "?" >
 485 | <COLON: ":" >
 486 | <EQ: "==" >
 487 | <LE: "<=" >
 488 | <GE: ">=" >
 489 | <NE: "!=" >
 490 | <SC_OR: "||" >
 491 | <SC_AND: "&&" >
 492 | <INCR: "++" >
 493 | <DECR: "--" >
 494 | <PLUS: "+" >
 495 | <MINUS: "-" >
 496 | <STAR: "*" >
 497 | <SLASH: "/" >
 498 | <BIT_AND: "&" >
 499 | <BIT_OR: "|" >
 500 | <XOR: "^" >
 501 | <REM: "%" >
 502 | <LSHIFT: "<<" >
 503 | <RSIGNEDSHIFT: ">>" >
 504 | <RUNSIGNEDSHIFT: ">>>" >
 505 | <PLUSASSIGN: "+=" >
 506 | <MINUSASSIGN: "-=" >
 507 | <STARASSIGN: "*=" >
 508 | <SLASHASSIGN: "/=" >
 509 | <ANDASSIGN: "&=" >
 510 | <ORASSIGN: "|=" >
 511 | <XORASSIGN: "^=" >
 512 | <DOTASSIGN: ".=" >
 513 | <REMASSIGN: "%=" >
 514 | <LSHIFTASSIGN: "<<=" >
 515 | <RSIGNEDSHIFTASSIGN: ">>=" >
 516 | <BANGDOUBLEEQUAL: "!==" >
 517 | <TRIPLEEQUAL: "===" >
 518 | <TILDEEQUAL: "~=" >
 519 }
 520
 521 <PHPPARSING> TOKEN :
 522 {
 523   < DOLLAR_ID: <DOLLAR> <IDENTIFIER>  >
 524 }
 525
 526 /*****************************************
 527  * THE JAVA LANGUAGE GRAMMAR STARTS HERE *
 528  *****************************************/
 529
 530 /*
 531  * Program structuring syntax follows.
 532  */
 533
 534 void phpTest() :
 535 {}
 536 {
 537   Php()
 538   <EOF>
 539 }
 540
 541 void phpFile() :
 542 {}
 543 {
 544   try {
 545   (<PHPSTART> Php() <PHPEND>)*
 546   <EOF>
 547   } catch (TokenMgrError e) {
 548     errorMessage = e.getMessage();
 549     errorLevel   = ERROR;
 550     throw generateParseException();
 551   }
 552 }
 553
 554 void Php() :
 555 {}
 556 {
 557   (BlockStatement())*
 558 }
 559
 560 void ClassDeclaration() :
 561 {
 562   PHPClassDeclaration classDeclaration;
 563   Token className;
 564   int pos = jj_input_stream.bufpos;
 565 }
 566 {
 567   <CLASS> className = <IDENTIFIER> [ <EXTENDS> <IDENTIFIER> ]
 568   {
 569     classDeclaration = new PHPClassDeclaration(currentSegment,className.image,pos);
 570     currentSegment.add(classDeclaration);
 571     currentSegment = classDeclaration;
 572   }
 573   ClassBody()
 574   {
 575     currentSegment = (PHPSegmentWithChildren) currentSegment.getParent();
 576   }
 577 }
 578
 579 void ClassBody() :
 580 {}
 581 {
 582   try {
 583     <LBRACE>
 584   } catch (ParseException e) {
 585     errorMessage = "'{' expected";
 586     errorLevel   = ERROR;
 587     throw e;
 588   }
 589   ( ClassBodyDeclaration() )*
 590   try {
 591     <RBRACE>
 592   } catch (ParseException e) {
 593     errorMessage = "'var', 'function' or '}' expected";
 594     errorLevel   = ERROR;
 595     throw e;
 596   }
 597 }
 598
 599 void ClassBodyDeclaration() :
 600 {}
 601 {
 602   MethodDeclaration()
 603 |
 604   FieldDeclaration()
 605 }
 606
 607 void FieldDeclaration() :
 608 {
 609   PHPVarDeclaration variableDeclaration;
 610 }
 611 {
 612   <VAR> variableDeclaration = VariableDeclarator()
 613   {currentSegment.add(variableDeclaration);}
 614   ( <COMMA>
 615     variableDeclaration = VariableDeclarator()
 616     {currentSegment.add(variableDeclaration);}
 617   )*
 618   try {
 619     <SEMICOLON>
 620   } catch (ParseException e) {
 621     errorMessage = "';' expected after variable declaration";
 622     errorLevel   = ERROR;
 623     throw e;
 624   }
 625 }
 626
 627 PHPVarDeclaration VariableDeclarator() :
 628 {
 629   String varName;
 630   String varValue = null;
 631   int pos = jj_input_stream.bufpos;
 632 }
 633 {
 634   varName = VariableDeclaratorId()
 635   [
 636     <ASSIGN>
 637     try {
 638       varValue = VariableInitializer()
 639     } catch (ParseException e) {
 640       errorMessage = "Literal expression expected in variable initializer";
 641       errorLevel   = ERROR;
 642       throw e;
 643     }
 644   ]
 645   {
 646     if (varValue == null) {
 647       return new PHPVarDeclaration(currentSegment,varName,pos);
 648     }
 649     return new PHPVarDeclaration(currentSegment,varName,pos,varValue);
 650   }
 651 }
 652
 653 String VariableDeclaratorId() :
 654 {
 655   String expr;
 656   StringBuffer buff = new StringBuffer();
 657 }
 658 {
 659   try {
 660     expr = Variable()
 661     {buff.append(expr);}
 662     ( LOOKAHEAD(2) expr = VariableSuffix()
 663     {buff.append(expr);}
 664     )*
 665     {return buff.toString();}
 666   } catch (ParseException e) {
 667     errorMessage = "'$' expected for variable identifier";
 668     errorLevel   = ERROR;
 669     throw e;
 670   }
 671 }
 672
 673 String Variable():
 674 {
 675   String expr = null;
 676   Token token;
 677 }
 678 {
 679   token = <DOLLAR_ID> [<LBRACE> expr = Expression() <RBRACE>]
 680   {
 681     if (expr == null) {
 682       return token.image;
 683     }
 684     return token + "{" + expr + "}";
 685   }
 686 |
 687   <DOLLAR> expr = VariableName()
 688   {return "$" + expr;}
 689 }
 690
 691 String VariableName():
 692 {
 693 String expr = null;
 694 Token token;
 695 }
 696 {
 697   <LBRACE> expr = Expression() <RBRACE>
 698   {return "{"+expr+"}";}
 699 |
 700   token = <IDENTIFIER> [<LBRACE> expr = Expression() <RBRACE>]
 701   {
 702     if (expr == null) {
 703       return token.image;
 704     }
 705     return token + "{" + expr + "}";
 706   }
 707 |
 708   <DOLLAR> expr = VariableName()
 709   {return "$" + expr;}
 710 |
 711   token = <DOLLAR_ID> [expr = VariableName()]
 712   {
 713   if (expr == null) {
 714     return token.image;
 715   }
 716   return token.image + expr;
 717   }
 718 }
 719
 720 String VariableInitializer() :
 721 {
 722   String expr;
 723   Token token;
 724 }
 725 {
 726   expr = Literal()
 727   {return expr;}
 728 |
 729   <MINUS> (token = <INTEGER_LITERAL> | token = <FLOATING_POINT_LITERAL>)
 730   {return "-" + token.image;}
 731 |
 732   <PLUS> (token = <INTEGER_LITERAL> | token = <FLOATING_POINT_LITERAL>)
 733   {return "+" + token.image;}
 734 |
 735   expr = ArrayDeclarator()
 736   {return expr;}
 737 |
 738   token = <IDENTIFIER>
 739   {return token.image;}
 740 }
 741
 742 String ArrayVariable() :
 743 {
 744 String expr;
 745 StringBuffer buff = new StringBuffer();
 746 }
 747 {
 748   expr = Expression()
 749   {buff.append(expr);}
 750    [<ARRAYASSIGN> expr = Expression()
 751    {buff.append("=>").append(expr);}]
 752   {return buff.toString();}
 753 }
 754
 755 String ArrayInitializer() :
 756 {
 757 String expr = null;
 758 StringBuffer buff = new StringBuffer("(");
 759 }
 760 {
 761   <LPAREN> [ expr = ArrayVariable()
 762             {buff.append(expr);}
 763             ( LOOKAHEAD(2) <COMMA> expr = ArrayVariable()
 764             {buff.append(",").append(expr);}
 765             )* ]
 766   <RPAREN>
 767   {
 768     buff.append(")");
 769     return buff.toString();
 770   }
 771 }
 772
 773 void MethodDeclaration() :
 774 {
 775   PHPFunctionDeclaration functionDeclaration;
 776 }
 777 {
 778   <FUNCTION> functionDeclaration = MethodDeclarator()
 779   {
 780     currentSegment.add(functionDeclaration);
 781     currentSegment = functionDeclaration;
 782   }
 783   Block()
 784   {
 785     currentSegment = (PHPSegmentWithChildren) currentSegment.getParent();
 786   }
 787 }
 788
 789 PHPFunctionDeclaration MethodDeclarator() :
 790 {
 791   Token identifier;
 792   StringBuffer methodDeclaration = new StringBuffer();
 793   String formalParameters;
 794   int pos = jj_input_stream.bufpos;
 795 }
 796 {
 797   [ <BIT_AND> {methodDeclaration.append("&");} ]
 798   identifier = <IDENTIFIER>
 799   {methodDeclaration.append(identifier);}
 800     formalParameters = FormalParameters()
 801   {
 802     methodDeclaration.append(formalParameters);
 803     return new PHPFunctionDeclaration(currentSegment,methodDeclaration.toString(),pos);
 804   }
 805 }
 806
 807 String FormalParameters() :
 808 {
 809   String expr;
 810   final StringBuffer buff = new StringBuffer("(");
 811 }
 812 {
 813   try {
 814   <LPAREN>
 815   } catch (ParseException e) {
 816     errorMessage = "Formal parameter expected after function identifier";
 817     errorLevel   = ERROR;
 818     jj_consume_token(token.kind);
 819   }
 820             [ expr = FormalParameter()
 821               {buff.append(expr);}
 822             (
 823                 <COMMA> expr = FormalParameter()
 824                 {buff.append(",").append(expr);}
 825             )*
 826             ]
 827   try {
 828     <RPAREN>
 829   } catch (ParseException e) {
 830     errorMessage = "')' expected";
 831     errorLevel   = ERROR;
 832     throw e;
 833   }
 834  {
 835   buff.append(")");
 836   return buff.toString();
 837  }
 838 }
 839
 840 String FormalParameter() :
 841 {
 842   PHPVarDeclaration variableDeclaration;
 843   StringBuffer buff = new StringBuffer();
 844 }
 845 {
 846   [<BIT_AND> {buff.append("&");}] variableDeclaration = VariableDeclarator()
 847   {
 848     buff.append(variableDeclaration.toString());
 849     return buff.toString();
 850   }
 851 }
 852
 853 String Type() :
 854 {}
 855 {
 856   <STRING>
 857   {return "string";}
 858 |
 859   <BOOL>
 860   {return "bool";}
 861 |
 862   <BOOLEAN>
 863   {return "boolean";}
 864 |
 865   <REAL>
 866   {return "real";}
 867 |
 868   <DOUBLE>
 869   {return "double";}
 870 |
 871   <FLOAT>
 872   {return "float";}
 873 |
 874   <INT>
 875   {return "int";}
 876 |
 877   <INTEGER>
 878   {return "integer";}
 879 |
 880   <OBJECT>
 881   {return "object";}
 882 }
 883
 884 String Expression() :
 885 {
 886   String expr;
 887   String assignOperator = null;
 888   String expr2 = null;
 889 }
 890 {
 891   expr = PrintExpression()
 892   {return expr;}
 893 |
 894   expr = ConditionalExpression()
 895   [
 896     assignOperator = AssignmentOperator()
 897     try {
 898       expr2 = Expression()
 899     } catch (ParseException e) {
 900       errorMessage = "expression expected";
 901       errorLevel   = ERROR;
 902       throw e;
 903     }
 904   ]
 905   {
 906     if (expr2 == null) {
 907       return expr;
 908     } else {
 909       return expr + assignOperator + expr2;
 910     }
 911   }
 912 }
 913
 914 String AssignmentOperator() :
 915 {}
 916 {
 917   <ASSIGN>
 918 {return "=";}
 919 | <STARASSIGN>
 920 {return "*=";}
 921 | <SLASHASSIGN>
 922 {return "/=";}
 923 | <REMASSIGN>
 924 {return "%=";}
 925 | <PLUSASSIGN>
 926 {return "+=";}
 927 | <MINUSASSIGN>
 928 {return "-=";}
 929 | <LSHIFTASSIGN>
 930 {return "<<=";}
 931 | <RSIGNEDSHIFTASSIGN>
 932 {return ">>=";}
 933 | <ANDASSIGN>
 934 {return "&=";}
 935 | <XORASSIGN>
 936 {return "|=";}
 937 | <ORASSIGN>
 938 {return "|=";}
 939 | <DOTASSIGN>
 940 {return ".=";}
 941 | <TILDEEQUAL>
 942 {return "~=";}
 943 }
 944
 945 String ConditionalExpression() :
 946 {
 947   String expr;
 948   String expr2 = null;
 949   String expr3 = null;
 950 }
 951 {
 952   expr = ConditionalOrExpression() [ <HOOK> expr2 = Expression() <COLON> expr3 = ConditionalExpression() ]
 953 {
 954   if (expr3 == null) {
 955     return expr;
 956   } else {
 957     return expr + "?" + expr2 + ":" + expr3;
 958   }
 959 }
 960 }
 961
 962 String ConditionalOrExpression() :
 963 {
 964   String expr;
 965   Token operator;
 966   String expr2 = null;
 967   StringBuffer buff = new StringBuffer();
 968 }
 969 {
 970   expr = ConditionalAndExpression()
 971   {
 972     buff.append(expr);
 973   }
 974   (
 975     (operator = <SC_OR> | operator = <_ORL>) expr2 = ConditionalAndExpression()
 976     {
 977       buff.append(operator.image);
 978       buff.append(expr2);
 979     }
 980   )*
 981   {
 982     return buff.toString();
 983   }
 984 }
 985
 986 String ConditionalAndExpression() :
 987 {
 988   String expr;
 989   Token operator;
 990   String expr2 = null;
 991   StringBuffer buff = new StringBuffer();
 992 }
 993 {
 994   expr = ConcatExpression()
 995   {
 996     buff.append(expr);
 997   }
 998   (
 999   (operator = <SC_AND> | operator = <_ANDL>) expr2 = ConcatExpression()
1000     {
1001       buff.append(operator.image);
1002       buff.append(expr2);
1003     }
1004   )*
1005   {
1006     return buff.toString();
1007   }
1008 }
1009
1010 String ConcatExpression() :
1011 {
1012   String expr;
1013   String expr2 = null;
1014   StringBuffer buff = new StringBuffer();
1015 }
1016 {
1017   expr = InclusiveOrExpression()
1018   {
1019     buff.append(expr);
1020   }
1021   (
1022   <DOT> expr2 = InclusiveOrExpression()
1023   {
1024     buff.append(".");
1025     buff.append(expr2);
1026   }
1027   )*
1028   {
1029     return buff.toString();
1030   }
1031 }
1032
1033 String InclusiveOrExpression() :
1034 {
1035   String expr;
1036   String expr2 = null;
1037   StringBuffer buff = new StringBuffer();
1038 }
1039 {
1040   expr = ExclusiveOrExpression()
1041   {
1042     buff.append(expr);
1043   }
1044   (
1045   <BIT_OR> expr2 = ExclusiveOrExpression()
1046   {
1047     buff.append("|");
1048     buff.append(expr2);
1049   }
1050   )*
1051   {
1052     return buff.toString();
1053   }
1054 }
1055
1056 String ExclusiveOrExpression() :
1057 {
1058   String expr;
1059   String expr2 = null;
1060   StringBuffer buff = new StringBuffer();
1061 }
1062 {
1063   expr = AndExpression()
1064   {
1065     buff.append(expr);
1066   }
1067   (
1068     <XOR> expr2 = AndExpression()
1069   {
1070     buff.append("^");
1071     buff.append(expr2);
1072   }
1073   )*
1074   {
1075     return buff.toString();
1076   }
1077 }
1078
1079 String AndExpression() :
1080 {
1081   String expr;
1082   String expr2 = null;
1083   StringBuffer buff = new StringBuffer();
1084 }
1085 {
1086   expr = EqualityExpression()
1087   {
1088     buff.append(expr);
1089   }
1090   (
1091     <BIT_AND> expr2 = EqualityExpression()
1092   {
1093     buff.append("&");
1094     buff.append(expr2);
1095   }
1096   )*
1097   {
1098     return buff.toString();
1099   }
1100 }
1101
1102 String EqualityExpression() :
1103 {
1104   String expr;
1105   Token operator;
1106   String expr2;
1107   StringBuffer buff = new StringBuffer();
1108 }
1109 {
1110   expr = RelationalExpression()
1111   {buff.append(expr);}
1112   (
1113   (   operator = <EQ>
1114     | operator = <NE>
1115     | operator = <BANGDOUBLEEQUAL>
1116     | operator = <TRIPLEEQUAL>
1117   )
1118   expr2 = RelationalExpression()
1119   {
1120     buff.append(operator.image);
1121     buff.append(expr2);
1122   }
1123   )*
1124   {return buff.toString();}
1125 }
1126
1127 String RelationalExpression() :
1128 {
1129   String expr;
1130   Token operator;
1131   String expr2;
1132   StringBuffer buff = new StringBuffer();
1133 }
1134 {
1135   expr = ShiftExpression()
1136   {buff.append(expr);}
1137   (
1138   ( operator = <LT> | operator = <GT> | operator = <LE> | operator = <GE> ) expr2 = ShiftExpression()
1139   {
1140     buff.append(operator.image);
1141     buff.append(expr2);
1142   }
1143   )*
1144   {return buff.toString();}
1145 }
1146
1147 String ShiftExpression() :
1148 {
1149   String expr;
1150   Token operator;
1151   String expr2;
1152   StringBuffer buff = new StringBuffer();
1153 }
1154 {
1155   expr = AdditiveExpression()
1156   {buff.append(expr);}
1157   (
1158   (operator = <LSHIFT> | operator = <RSIGNEDSHIFT> | operator = <RUNSIGNEDSHIFT> ) expr2 = AdditiveExpression()
1159   {
1160     buff.append(operator.image);
1161     buff.append(expr2);
1162   }
1163   )*
1164   {return buff.toString();}
1165 }
1166
1167 String AdditiveExpression() :
1168 {
1169   String expr;
1170   Token operator;
1171   String expr2;
1172   StringBuffer buff = new StringBuffer();
1173 }
1174 {
1175   expr = MultiplicativeExpression()
1176   {buff.append(expr);}
1177   (
1178    ( operator = <PLUS> | operator = <MINUS> ) expr2 = MultiplicativeExpression()
1179   {
1180     buff.append(operator.image);
1181     buff.append(expr2);
1182   }
1183    )*
1184   {return buff.toString();}
1185 }
1186
1187 String MultiplicativeExpression() :
1188 {
1189   String expr, expr2;
1190   Token operator;
1191   final StringBuffer buff = new StringBuffer();}
1192 {
1193   expr = UnaryExpression()
1194   {buff.append(expr);}
1195   (
1196   ( operator = <STAR> | operator = <SLASH> | operator = <REM> ) expr2 = UnaryExpression()
1197   {
1198     buff.append(operator.image);
1199     buff.append(expr2);
1200   }
1201   )*
1202   {return buff.toString();}
1203 }
1204
1205 /**
1206  * An unary expression starting with @, & or nothing
1207  */
1208 String UnaryExpression() :
1209 {
1210   String expr;
1211   Token token;
1212   final StringBuffer buff = new StringBuffer();
1213 }
1214 {
1215   token = <BIT_AND> expr = UnaryExpressionNoPrefix()
1216   {
1217     if (token == null) {
1218       return expr;
1219     }
1220     return token.image + expr;
1221   }
1222 |
1223   (<AT> {buff.append("@");})* expr = UnaryExpressionNoPrefix()
1224   {return buff.append(expr).toString();}
1225 }
1226
1227 String UnaryExpressionNoPrefix() :
1228 {
1229   String expr;
1230   Token token;
1231 }
1232 {
1233   ( token = <PLUS> | token = <MINUS> ) expr = UnaryExpression()
1234   {
1235     return token.image + expr;
1236   }
1237 |
1238   expr = PreIncrementExpression()
1239   {return expr;}
1240 |
1241   expr = PreDecrementExpression()
1242   {return expr;}
1243 |
1244   expr = UnaryExpressionNotPlusMinus()
1245   {return expr;}
1246 }
1247
1248
1249 String PreIncrementExpression() :
1250 {
1251 String expr;
1252 }
1253 {
1254   <INCR> expr = PrimaryExpression()
1255   {return "++"+expr;}
1256 }
1257
1258 String PreDecrementExpression() :
1259 {
1260 String expr;
1261 }
1262 {
1263   <DECR> expr = PrimaryExpression()
1264   {return "--"+expr;}
1265 }
1266
1267 String UnaryExpressionNotPlusMinus() :
1268 {
1269   String expr;
1270 }
1271 {
1272   <BANG> expr = UnaryExpression()
1273   {return "!" + expr;}
1274 |
1275   LOOKAHEAD( <LPAREN> Type() <RPAREN> )
1276   expr = CastExpression()
1277   {return expr;}
1278 |
1279   expr = PostfixExpression()
1280   {return expr;}
1281 |
1282   expr = Literal()
1283   {return expr;}
1284 |
1285   <LPAREN> expr = Expression()<RPAREN>
1286   {return "("+expr+")";}
1287 }
1288
1289 String CastExpression() :
1290 {
1291 String type;
1292 String expr;
1293 }
1294 {
1295   <LPAREN> type = Type() <RPAREN> expr = UnaryExpression()
1296   {return "(" + type + ")" + expr;}
1297 }
1298
1299 String PostfixExpression() :
1300 {
1301   String expr;
1302   Token operator = null;
1303 }
1304 {
1305   expr = PrimaryExpression() [ operator = <INCR> | operator = <DECR> ]
1306   {
1307     if (operator == null) {
1308       return expr;
1309     }
1310     return expr + operator.image;
1311   }
1312 }
1313
1314 String PrimaryExpression() :
1315 {
1316   Token identifier;
1317   String expr;
1318   final StringBuffer buff = new StringBuffer();
1319 }
1320 {
1321   LOOKAHEAD(2)
1322   identifier = <IDENTIFIER> <STATICCLASSACCESS> expr = ClassIdentifier()
1323   {buff.append(identifier.image).append("::").append(expr);}
1324   (
1325   expr = PrimarySuffix()
1326   {buff.append(expr);}
1327   )*
1328   {return buff.toString();}
1329 |
1330   expr = PrimaryPrefix()  {buff.append(expr);}
1331   ( expr = PrimarySuffix()  {buff.append(expr);} )*
1332   {return buff.toString();}
1333 |
1334   expr = ArrayDeclarator()
1335   {return "array" + expr;}
1336 }
1337
1338 String ArrayDeclarator() :
1339 {
1340   String expr;
1341 }
1342 {
1343   <ARRAY> expr = ArrayInitializer()
1344   {return "array" + expr;}
1345 }
1346
1347 String PrimaryPrefix() :
1348 {
1349   String expr;
1350   Token token = null;
1351 }
1352 {
1353   token = <IDENTIFIER>
1354   {return token.image;}
1355 |
1356   <NEW> expr = ClassIdentifier()
1357   {
1358     return "new " + expr;
1359   }
1360 |
1361   expr = VariableDeclaratorId()
1362   {return expr;}
1363 }
1364
1365 String ClassIdentifier():
1366 {
1367   String expr;
1368   Token token;
1369 }
1370 {
1371   token = <IDENTIFIER>
1372   {return token.image;}
1373 |
1374   expr = VariableDeclaratorId()
1375   {return expr;}
1376 }
1377
1378 String PrimarySuffix() :
1379 {
1380   String expr;
1381 }
1382 {
1383   expr = Arguments()
1384   {return expr;}
1385 |
1386   expr = VariableSuffix()
1387   {return expr;}
1388 }
1389
1390 String VariableSuffix() :
1391 {
1392   String expr = null;
1393 }
1394 {
1395   <CLASSACCESS> expr = VariableName()
1396   {return "->" + expr;}
1397 |
1398   <LBRACKET> [ expr = Expression() ]
1399   try {
1400     <RBRACKET>
1401   } catch (ParseException e) {
1402     errorMessage = "']' expected";
1403     errorLevel   = ERROR;
1404     throw e;
1405   }
1406   {
1407     if(expr == null) {
1408       return "[]";
1409     }
1410     return "[" + expr + "]";
1411   }
1412 }
1413
1414 String Literal() :
1415 {
1416   String expr;
1417   Token token;
1418 }
1419 {
1420   token = <INTEGER_LITERAL>
1421   {return token.image;}
1422 |
1423   token = <FLOATING_POINT_LITERAL>
1424   {return token.image;}
1425 |
1426   token = <STRING_LITERAL>
1427   {return token.image;}
1428 |
1429   expr = BooleanLiteral()
1430   {return expr;}
1431 |
1432   expr = NullLiteral()
1433   {return expr;}
1434 }
1435
1436 String BooleanLiteral() :
1437 {}
1438 {
1439   <TRUE>
1440   {return "true";}
1441 |
1442   <FALSE>
1443   {return "false";}
1444 }
1445
1446 String NullLiteral() :
1447 {}
1448 {
1449   <NULL>
1450   {return "null";}
1451 }
1452
1453 String Arguments() :
1454 {
1455 String expr = null;
1456 }
1457 {
1458   <LPAREN> [ expr = ArgumentList() ]
1459   try {
1460     <RPAREN>
1461   } catch (ParseException e) {
1462     errorMessage = "')' expected to close the argument list";
1463     errorLevel   = ERROR;
1464     throw e;
1465   }
1466   {
1467   if (expr == null) {
1468     return "()";
1469   }
1470   return "(" + expr + ")";
1471   }
1472 }
1473
1474 String ArgumentList() :
1475 {
1476 String expr;
1477 StringBuffer buff = new StringBuffer();
1478 }
1479 {
1480   expr = Expression()
1481   {buff.append(expr);}
1482   ( <COMMA>
1483       try {
1484         expr = Expression()
1485       } catch (ParseException e) {
1486         errorMessage = "expression expected after a comma in argument list";
1487         errorLevel   = ERROR;
1488         throw e;
1489       }
1490     {
1491       buff.append(",").append("expr");
1492     }
1493    )*
1494    {return buff.toString();}
1495 }
1496
1497 /*
1498  * Statement syntax follows.
1499  */
1500
1501 void Statement() :
1502 {}
1503 {
1504   LOOKAHEAD(2)
1505   Expression()
1506   try {
1507     (<SEMICOLON> | "?>")
1508   } catch (ParseException e) {
1509     errorMessage = "';' expected";
1510     errorLevel   = ERROR;
1511     throw e;
1512   }
1513 |
1514   LOOKAHEAD(2)
1515   LabeledStatement()
1516 |
1517   Block()
1518 |
1519   EmptyStatement()
1520 |
1521   StatementExpression()
1522   try {
1523     <SEMICOLON>
1524   } catch (ParseException e) {
1525     errorMessage = "';' expected after expression";
1526     errorLevel   = ERROR;
1527     throw e;
1528   }
1529 |
1530   SwitchStatement()
1531 |
1532   IfStatement()
1533 |
1534   WhileStatement()
1535 |
1536   DoStatement()
1537 |
1538   ForStatement()
1539 |
1540   ForeachStatement()
1541 |
1542   BreakStatement()
1543 |
1544   ContinueStatement()
1545 |
1546   ReturnStatement()
1547 |
1548   EchoStatement()
1549 |
1550   [<AT>] IncludeStatement()
1551 |
1552   StaticStatement()
1553 |
1554   GlobalStatement()
1555 }
1556
1557 void IncludeStatement() :
1558 {
1559   String expr;
1560   int pos = jj_input_stream.bufpos;
1561 }
1562 {
1563   <REQUIRE>
1564   expr = Expression()
1565   {currentSegment.add(new PHPReqIncDeclaration(currentSegment, "require",pos,expr));}
1566   try {
1567     (<SEMICOLON> | "?>")
1568   } catch (ParseException e) {
1569     errorMessage = "';' expected";
1570     errorLevel   = ERROR;
1571     throw e;
1572   }
1573 |
1574   <REQUIRE_ONCE>
1575   expr = Expression()
1576   {currentSegment.add(new PHPReqIncDeclaration(currentSegment, "require_once",pos,expr));}
1577   try {
1578     (<SEMICOLON> | "?>")
1579   } catch (ParseException e) {
1580     errorMessage = "';' expected";
1581     errorLevel   = ERROR;
1582     throw e;
1583   }
1584 |
1585   <INCLUDE>
1586   expr = Expression()
1587   {currentSegment.add(new PHPReqIncDeclaration(currentSegment, "include",pos,expr));}
1588   try {
1589     (<SEMICOLON> | "?>")
1590   } catch (ParseException e) {
1591     errorMessage = "';' expected";
1592     errorLevel   = ERROR;
1593     throw e;
1594   }
1595 |
1596   <INCLUDE_ONCE>
1597   expr = Expression()
1598   {currentSegment.add(new PHPReqIncDeclaration(currentSegment, "include_once",pos,expr));}
1599   try {
1600     (<SEMICOLON> | "?>")
1601   } catch (ParseException e) {
1602     errorMessage = "';' expected";
1603     errorLevel   = ERROR;
1604     throw e;
1605   }
1606 }
1607
1608 String PrintExpression() :
1609 {
1610   StringBuffer buff = new StringBuffer("print ");
1611   String expr;
1612 }
1613 {
1614   <PRINT> expr = Expression()
1615   {
1616     buff.append(expr);
1617     return buff.toString();
1618   }
1619 }
1620
1621 void EchoStatement() :
1622 {}
1623 {
1624   <ECHO> Expression() (<COMMA> Expression())*
1625   try {
1626     (<SEMICOLON> | "?>")
1627   } catch (ParseException e) {
1628     errorMessage = "';' expected after 'echo' statement";
1629     errorLevel   = ERROR;
1630     throw e;
1631   }
1632 }
1633
1634 void GlobalStatement() :
1635 {}
1636 {
1637   <GLOBAL> VariableDeclaratorId() (<COMMA> VariableDeclaratorId())*
1638   try {
1639     (<SEMICOLON> | "?>")
1640   } catch (ParseException e) {
1641     errorMessage = "';' expected";
1642     errorLevel   = ERROR;
1643     throw e;
1644   }
1645 }
1646
1647 void StaticStatement() :
1648 {}
1649 {
1650   <STATIC> VariableDeclarator() (<COMMA> VariableDeclarator())*
1651   try {
1652     (<SEMICOLON> | "?>")
1653   } catch (ParseException e) {
1654     errorMessage = "';' expected";
1655     errorLevel   = ERROR;
1656     throw e;
1657   }
1658 }
1659
1660 void LabeledStatement() :
1661 {}
1662 {
1663   <IDENTIFIER> <COLON> Statement()
1664 }
1665
1666 void Block() :
1667 {}
1668 {
1669   try {
1670     <LBRACE>
1671   } catch (ParseException e) {
1672     errorMessage = "'{' expected";
1673     errorLevel   = ERROR;
1674     throw e;
1675   }
1676   ( BlockStatement() )*
1677   <RBRACE>
1678 }
1679
1680 void BlockStatement() :
1681 {}
1682 {
1683   Statement()
1684 |
1685   ClassDeclaration()
1686 |
1687   MethodDeclaration()
1688 }
1689
1690 void LocalVariableDeclaration() :
1691 {}
1692 {
1693   VariableDeclarator() ( <COMMA> VariableDeclarator() )*
1694 }
1695
1696 void EmptyStatement() :
1697 {}
1698 {
1699   <SEMICOLON>
1700 }
1701
1702 void StatementExpression() :
1703 {}
1704 {
1705   PreIncrementExpression()
1706 |
1707   PreDecrementExpression()
1708 |
1709   PrimaryExpression()
1710   [
1711    <INCR>
1712   |
1713     <DECR>
1714   |
1715     AssignmentOperator() Expression()
1716   ]
1717 }
1718
1719 void SwitchStatement() :
1720 {}
1721 {
1722   <SWITCH> <LPAREN> Expression() <RPAREN> <LBRACE>
1723     ( SwitchLabel() ( BlockStatement() )* )*
1724   <RBRACE>
1725 }
1726
1727 void SwitchLabel() :
1728 {}
1729 {
1730   <CASE> Expression() <COLON>
1731 |
1732   <_DEFAULT> <COLON>
1733 }
1734
1735 void IfStatement() :
1736 /*
1737  * The disambiguating algorithm of JavaCC automatically binds dangling
1738  * else's to the innermost if statement.  The LOOKAHEAD specification
1739  * is to tell JavaCC that we know what we are doing.
1740  */
1741 {}
1742 {
1743   <IF> Condition("if") Statement() ( LOOKAHEAD(1) ElseIfStatement() )* [ LOOKAHEAD(1) <ELSE> Statement() ]
1744 }
1745
1746 void Condition(String keyword) :
1747 {}
1748 {
1749   try {
1750     <LPAREN>
1751   } catch (ParseException e) {
1752     errorMessage = "'(' expected after " + keyword + " keyword";
1753     errorLevel   = ERROR;
1754     throw e;
1755   }
1756   Expression()
1757   try {
1758      <RPAREN>
1759   } catch (ParseException e) {
1760     errorMessage = "')' expected after " + keyword + " keyword";
1761     errorLevel   = ERROR;
1762     throw e;
1763   }
1764 }
1765
1766 void ElseIfStatement() :
1767 {}
1768 {
1769   <ELSEIF> Condition("elseif") Statement()
1770 }
1771
1772 void WhileStatement() :
1773 {}
1774 {
1775   <WHILE> Condition("while") WhileStatement0()
1776 }
1777
1778 void WhileStatement0() :
1779 {}
1780 {
1781   <COLON> (Statement())* <ENDWHILE>
1782   try {
1783     (<SEMICOLON> | "?>")
1784   } catch (ParseException e) {
1785     errorMessage = "';' expected";
1786     errorLevel   = ERROR;
1787     throw e;
1788   }
1789 |
1790   Statement()
1791 }
1792
1793 void DoStatement() :
1794 {}
1795 {
1796   <DO> Statement() <WHILE> Condition("while")
1797   try {
1798     (<SEMICOLON> | "?>")
1799   } catch (ParseException e) {
1800     errorMessage = "';' expected";
1801     errorLevel   = ERROR;
1802     throw e;
1803   }
1804 }
1805
1806 void ForeachStatement() :
1807 {}
1808 {
1809   <FOREACH> <LPAREN> Variable() <AS> Variable() [ <ARRAYASSIGN> Expression() ] <RPAREN> Statement()
1810 }
1811
1812 void ForStatement() :
1813 {}
1814 {
1815   <FOR> <LPAREN> [ ForInit() ] <SEMICOLON> [ Expression() ] <SEMICOLON> [ ForUpdate() ] <RPAREN> Statement()
1816 }
1817
1818 void ForInit() :
1819 {}
1820 {
1821   LOOKAHEAD(LocalVariableDeclaration())
1822   LocalVariableDeclaration()
1823 |
1824   StatementExpressionList()
1825 }
1826
1827 void StatementExpressionList() :
1828 {}
1829 {
1830   StatementExpression() ( <COMMA> StatementExpression() )*
1831 }
1832
1833 void ForUpdate() :
1834 {}
1835 {
1836   StatementExpressionList()
1837 }
1838
1839 void BreakStatement() :
1840 {}
1841 {
1842   <BREAK> [ <IDENTIFIER> ] <SEMICOLON>
1843 }
1844
1845 void ContinueStatement() :
1846 {}
1847 {
1848   <CONTINUE> [ <IDENTIFIER> ] <SEMICOLON>
1849 }
1850
1851 void ReturnStatement() :
1852 {}
1853 {
1854   <RETURN> [ Expression() ] <SEMICOLON>
1855 }