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