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