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