intial core test module
[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(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 static final 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 static final 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 final 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 final 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 static final 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()
553   try {
554     <PHPEND>
555   } catch (ParseException e) {
556     errorMessage = "'?>' expected";
557     errorLevel   = ERROR;
558     throw e;
559   }
560     )*
561   <EOF>
562   } catch (TokenMgrError e) {
563     errorMessage = e.getMessage();
564     errorLevel   = ERROR;
565     throw generateParseException();
566   }
567 }
568
569 void Php() :
570 {}
571 {
572   (BlockStatement())*
573 }
574
575 void ClassDeclaration() :
576 {
577   PHPClassDeclaration classDeclaration;
578   Token className;
579   final int pos = jj_input_stream.bufpos;
580 }
581 {
582   <CLASS> className = <IDENTIFIER> [ <EXTENDS> <IDENTIFIER> ]
583   {
584     if (currentSegment != null) {
585       classDeclaration = new PHPClassDeclaration(currentSegment,className.image,pos);
586       currentSegment.add(classDeclaration);
587       currentSegment = classDeclaration;
588     }
589   }
590   ClassBody()
591   {
592     if (currentSegment != null) {
593       currentSegment = (PHPSegmentWithChildren) currentSegment.getParent();
594     }
595   }
596 }
597
598 void ClassBody() :
599 {}
600 {
601   try {
602     <LBRACE>
603   } catch (ParseException e) {
604     errorMessage = "'{' expected";
605     errorLevel   = ERROR;
606     throw e;
607   }
608   ( ClassBodyDeclaration() )*
609   try {
610     <RBRACE>
611   } catch (ParseException e) {
612     errorMessage = "'var', 'function' or '}' expected";
613     errorLevel   = ERROR;
614     throw e;
615   }
616 }
617
618 void ClassBodyDeclaration() :
619 {}
620 {
621   MethodDeclaration()
622 |
623   FieldDeclaration()
624 }
625
626 void FieldDeclaration() :
627 {
628   PHPVarDeclaration variableDeclaration;
629 }
630 {
631   <VAR> variableDeclaration = VariableDeclarator()
632   {
633     if (currentSegment != null) {
634       currentSegment.add(variableDeclaration);
635     }
636   }
637   ( <COMMA>
638       variableDeclaration = VariableDeclarator()
639       {
640       if (currentSegment != null) {
641         currentSegment.add(variableDeclaration);
642       }
643       }
644   )*
645   try {
646     <SEMICOLON>
647   } catch (ParseException e) {
648     errorMessage = "';' expected after variable declaration";
649     errorLevel   = ERROR;
650     throw e;
651   }
652 }
653
654 PHPVarDeclaration VariableDeclarator() :
655 {
656   String varName;
657   String varValue = null;
658   final int pos = jj_input_stream.bufpos;
659 }
660 {
661   varName = VariableDeclaratorId()
662   [
663     <ASSIGN>
664     try {
665       varValue = VariableInitializer()
666     } catch (ParseException e) {
667       errorMessage = "Literal expression expected in variable initializer";
668       errorLevel   = ERROR;
669       throw e;
670     }
671   ]
672   {
673     if (varValue == null) {
674       return new PHPVarDeclaration(currentSegment,varName,pos);
675     }
676     return new PHPVarDeclaration(currentSegment,varName,pos,varValue);
677   }
678 }
679
680 String VariableDeclaratorId() :
681 {
682   String expr;
683   final StringBuffer buff = new StringBuffer();
684 }
685 {
686   try {
687     expr = Variable()
688     {buff.append(expr);}
689     ( LOOKAHEAD(2) expr = VariableSuffix()
690     {buff.append(expr);}
691     )*
692     {return buff.toString();}
693   } catch (ParseException e) {
694     errorMessage = "'$' expected for variable identifier";
695     errorLevel   = ERROR;
696     throw e;
697   }
698 }
699
700 String Variable():
701 {
702   String expr = null;
703   Token token;
704 }
705 {
706   token = <DOLLAR_ID> [<LBRACE> expr = Expression() <RBRACE>]
707   {
708     if (expr == null) {
709       return token.image;
710     }
711     return token + "{" + expr + "}";
712   }
713 |
714   <DOLLAR> expr = VariableName()
715   {return "$" + expr;}
716 }
717
718 String VariableName():
719 {
720 String expr = null;
721 Token token;
722 }
723 {
724   <LBRACE> expr = Expression() <RBRACE>
725   {return "{"+expr+"}";}
726 |
727   token = <IDENTIFIER> [<LBRACE> expr = Expression() <RBRACE>]
728   {
729     if (expr == null) {
730       return token.image;
731     }
732     return token + "{" + expr + "}";
733   }
734 |
735   <DOLLAR> expr = VariableName()
736   {return "$" + expr;}
737 |
738   token = <DOLLAR_ID> [expr = VariableName()]
739   {
740   if (expr == null) {
741     return token.image;
742   }
743   return token.image + expr;
744   }
745 }
746
747 String VariableInitializer() :
748 {
749   String expr;
750   Token token;
751 }
752 {
753   expr = Literal()
754   {return expr;}
755 |
756   <MINUS> (token = <INTEGER_LITERAL> | token = <FLOATING_POINT_LITERAL>)
757   {return "-" + token.image;}
758 |
759   <PLUS> (token = <INTEGER_LITERAL> | token = <FLOATING_POINT_LITERAL>)
760   {return "+" + token.image;}
761 |
762   expr = ArrayDeclarator()
763   {return expr;}
764 |
765   token = <IDENTIFIER>
766   {return token.image;}
767 }
768
769 String ArrayVariable() :
770 {
771 String expr;
772 final StringBuffer buff = new StringBuffer();
773 }
774 {
775   expr = Expression()
776   {buff.append(expr);}
777    [<ARRAYASSIGN> expr = Expression()
778    {buff.append("=>").append(expr);}]
779   {return buff.toString();}
780 }
781
782 String ArrayInitializer() :
783 {
784 String expr = null;
785 final StringBuffer buff = new StringBuffer("(");
786 }
787 {
788   <LPAREN> [ expr = ArrayVariable()
789             {buff.append(expr);}
790             ( LOOKAHEAD(2) <COMMA> expr = ArrayVariable()
791             {buff.append(",").append(expr);}
792             )* ]
793   <RPAREN>
794   {
795     buff.append(")");
796     return buff.toString();
797   }
798 }
799
800 void MethodDeclaration() :
801 {
802   PHPFunctionDeclaration functionDeclaration;
803 }
804 {
805   <FUNCTION> functionDeclaration = MethodDeclarator()
806   {
807     if (currentSegment != null) {
808       currentSegment.add(functionDeclaration);
809       currentSegment = functionDeclaration;
810     }
811   }
812   Block()
813   {
814     if (currentSegment != null) {
815       currentSegment = (PHPSegmentWithChildren) currentSegment.getParent();
816     }
817   }
818 }
819
820 PHPFunctionDeclaration MethodDeclarator() :
821 {
822   Token identifier;
823   StringBuffer methodDeclaration = new StringBuffer();
824   String formalParameters;
825   final int pos = jj_input_stream.bufpos;
826 }
827 {
828   [ <BIT_AND> {methodDeclaration.append("&");} ]
829   identifier = <IDENTIFIER>
830   {methodDeclaration.append(identifier);}
831     formalParameters = FormalParameters()
832   {
833     methodDeclaration.append(formalParameters);
834     return new PHPFunctionDeclaration(currentSegment,methodDeclaration.toString(),pos);
835   }
836 }
837
838 String FormalParameters() :
839 {
840   String expr;
841   final StringBuffer buff = new StringBuffer("(");
842 }
843 {
844   try {
845   <LPAREN>
846   } catch (ParseException e) {
847     errorMessage = "Formal parameter expected after function identifier";
848     errorLevel   = ERROR;
849     jj_consume_token(token.kind);
850   }
851             [ expr = FormalParameter()
852               {buff.append(expr);}
853             (
854                 <COMMA> expr = FormalParameter()
855                 {buff.append(",").append(expr);}
856             )*
857             ]
858   try {
859     <RPAREN>
860   } catch (ParseException e) {
861     errorMessage = "')' expected";
862     errorLevel   = ERROR;
863     throw e;
864   }
865  {
866   buff.append(")");
867   return buff.toString();
868  }
869 }
870
871 String FormalParameter() :
872 {
873   PHPVarDeclaration variableDeclaration;
874   final StringBuffer buff = new StringBuffer();
875 }
876 {
877   [<BIT_AND> {buff.append("&");}] variableDeclaration = VariableDeclarator()
878   {
879     buff.append(variableDeclaration.toString());
880     return buff.toString();
881   }
882 }
883
884 String Type() :
885 {}
886 {
887   <STRING>
888   {return "string";}
889 |
890   <BOOL>
891   {return "bool";}
892 |
893   <BOOLEAN>
894   {return "boolean";}
895 |
896   <REAL>
897   {return "real";}
898 |
899   <DOUBLE>
900   {return "double";}
901 |
902   <FLOAT>
903   {return "float";}
904 |
905   <INT>
906   {return "int";}
907 |
908   <INTEGER>
909   {return "integer";}
910 |
911   <OBJECT>
912   {return "object";}
913 }
914
915 String Expression() :
916 {
917   String expr;
918   String assignOperator = null;
919   String expr2 = null;
920 }
921 {
922   expr = PrintExpression()
923   {return expr;}
924 |
925   expr = ConditionalExpression()
926   [
927     assignOperator = AssignmentOperator()
928     try {
929       expr2 = Expression()
930     } catch (ParseException e) {
931       errorMessage = "expression expected";
932       errorLevel   = ERROR;
933       throw e;
934     }
935   ]
936   {
937     if (expr2 == null) {
938       return expr;
939     } else {
940       return expr + assignOperator + expr2;
941     }
942   }
943 }
944
945 String AssignmentOperator() :
946 {}
947 {
948   <ASSIGN>
949 {return "=";}
950 | <STARASSIGN>
951 {return "*=";}
952 | <SLASHASSIGN>
953 {return "/=";}
954 | <REMASSIGN>
955 {return "%=";}
956 | <PLUSASSIGN>
957 {return "+=";}
958 | <MINUSASSIGN>
959 {return "-=";}
960 | <LSHIFTASSIGN>
961 {return "<<=";}
962 | <RSIGNEDSHIFTASSIGN>
963 {return ">>=";}
964 | <ANDASSIGN>
965 {return "&=";}
966 | <XORASSIGN>
967 {return "|=";}
968 | <ORASSIGN>
969 {return "|=";}
970 | <DOTASSIGN>
971 {return ".=";}
972 | <TILDEEQUAL>
973 {return "~=";}
974 }
975
976 String ConditionalExpression() :
977 {
978   String expr;
979   String expr2 = null;
980   String expr3 = null;
981 }
982 {
983   expr = ConditionalOrExpression() [ <HOOK> expr2 = Expression() <COLON> expr3 = ConditionalExpression() ]
984 {
985   if (expr3 == null) {
986     return expr;
987   } else {
988     return expr + "?" + expr2 + ":" + expr3;
989   }
990 }
991 }
992
993 String ConditionalOrExpression() :
994 {
995   String expr;
996   Token operator;
997   String expr2 = null;
998   final StringBuffer buff = new StringBuffer();
999 }
1000 {
1001   expr = ConditionalAndExpression()
1002   {
1003     buff.append(expr);
1004   }
1005   (
1006     (operator = <SC_OR> | operator = <_ORL>) expr2 = ConditionalAndExpression()
1007     {
1008       buff.append(operator.image);
1009       buff.append(expr2);
1010     }
1011   )*
1012   {
1013     return buff.toString();
1014   }
1015 }
1016
1017 String ConditionalAndExpression() :
1018 {
1019   String expr;
1020   Token operator;
1021   String expr2 = null;
1022   final StringBuffer buff = new StringBuffer();
1023 }
1024 {
1025   expr = ConcatExpression()
1026   {
1027     buff.append(expr);
1028   }
1029   (
1030   (operator = <SC_AND> | operator = <_ANDL>) expr2 = ConcatExpression()
1031     {
1032       buff.append(operator.image);
1033       buff.append(expr2);
1034     }
1035   )*
1036   {
1037     return buff.toString();
1038   }
1039 }
1040
1041 String ConcatExpression() :
1042 {
1043   String expr;
1044   String expr2 = null;
1045   final StringBuffer buff = new StringBuffer();
1046 }
1047 {
1048   expr = InclusiveOrExpression()
1049   {
1050     buff.append(expr);
1051   }
1052   (
1053   <DOT> expr2 = InclusiveOrExpression()
1054   {
1055     buff.append(".");
1056     buff.append(expr2);
1057   }
1058   )*
1059   {
1060     return buff.toString();
1061   }
1062 }
1063
1064 String InclusiveOrExpression() :
1065 {
1066   String expr;
1067   String expr2 = null;
1068   final StringBuffer buff = new StringBuffer();
1069 }
1070 {
1071   expr = ExclusiveOrExpression()
1072   {
1073     buff.append(expr);
1074   }
1075   (
1076   <BIT_OR> expr2 = ExclusiveOrExpression()
1077   {
1078     buff.append("|");
1079     buff.append(expr2);
1080   }
1081   )*
1082   {
1083     return buff.toString();
1084   }
1085 }
1086
1087 String ExclusiveOrExpression() :
1088 {
1089   String expr;
1090   String expr2 = null;
1091   final StringBuffer buff = new StringBuffer();
1092 }
1093 {
1094   expr = AndExpression()
1095   {
1096     buff.append(expr);
1097   }
1098   (
1099     <XOR> expr2 = AndExpression()
1100   {
1101     buff.append("^");
1102     buff.append(expr2);
1103   }
1104   )*
1105   {
1106     return buff.toString();
1107   }
1108 }
1109
1110 String AndExpression() :
1111 {
1112   final String expr;
1113   String expr2 = null;
1114   final StringBuffer buff = new StringBuffer();
1115 }
1116 {
1117   expr = EqualityExpression()
1118   {
1119     buff.append(expr);
1120   }
1121   (
1122     <BIT_AND> expr2 = EqualityExpression()
1123   {
1124     buff.append("&");
1125     buff.append(expr2);
1126   }
1127   )*
1128   {
1129     return buff.toString();
1130   }
1131 }
1132
1133 String EqualityExpression() :
1134 {
1135   String expr;
1136   Token operator;
1137   String expr2;
1138   final StringBuffer buff = new StringBuffer();
1139 }
1140 {
1141   expr = RelationalExpression()
1142   {buff.append(expr);}
1143   (
1144   (   operator = <EQ>
1145     | operator = <DIF>
1146     | operator = <NE>
1147     | operator = <BANGDOUBLEEQUAL>
1148     | operator = <TRIPLEEQUAL>
1149   )
1150   expr2 = RelationalExpression()
1151   {
1152     buff.append(operator.image);
1153     buff.append(expr2);
1154   }
1155   )*
1156   {return buff.toString();}
1157 }
1158
1159 String RelationalExpression() :
1160 {
1161   String expr;
1162   Token operator;
1163   String expr2;
1164   final StringBuffer buff = new StringBuffer();
1165 }
1166 {
1167   expr = ShiftExpression()
1168   {buff.append(expr);}
1169   (
1170   ( operator = <LT> | operator = <GT> | operator = <LE> | operator = <GE> ) expr2 = ShiftExpression()
1171   {
1172     buff.append(operator.image);
1173     buff.append(expr2);
1174   }
1175   )*
1176   {return buff.toString();}
1177 }
1178
1179 String ShiftExpression() :
1180 {
1181   String expr;
1182   Token operator;
1183   final StringBuffer buff = new StringBuffer();
1184 }
1185 {
1186   expr = AdditiveExpression()
1187   {buff.append(expr);}
1188   (
1189   (operator = <LSHIFT> | operator = <RSIGNEDSHIFT> | operator = <RUNSIGNEDSHIFT> ) expr = AdditiveExpression()
1190   {
1191     buff.append(operator.image);
1192     buff.append(expr);
1193   }
1194   )*
1195   {return buff.toString();}
1196 }
1197
1198 String AdditiveExpression() :
1199 {
1200   String expr;
1201   Token operator;
1202   final StringBuffer buff = new StringBuffer();
1203 }
1204 {
1205   expr = MultiplicativeExpression()
1206   {buff.append(expr);}
1207   (
1208    ( operator = <PLUS> | operator = <MINUS> ) expr = MultiplicativeExpression()
1209   {
1210     buff.append(operator.image);
1211     buff.append(expr);
1212   }
1213    )*
1214   {return buff.toString();}
1215 }
1216
1217 String MultiplicativeExpression() :
1218 {
1219   String expr;
1220   Token operator;
1221   final StringBuffer buff = new StringBuffer();}
1222 {
1223   expr = UnaryExpression()
1224   {buff.append(expr);}
1225   (
1226   ( operator = <STAR> | operator = <SLASH> | operator = <REM> ) expr = UnaryExpression()
1227   {
1228     buff.append(operator.image);
1229     buff.append(expr);
1230   }
1231   )*
1232   {return buff.toString();}
1233 }
1234
1235 /**
1236  * An unary expression starting with @, & or nothing
1237  */
1238 String UnaryExpression() :
1239 {
1240   String expr;
1241   Token token;
1242   final StringBuffer buff = new StringBuffer();
1243 }
1244 {
1245   token = <BIT_AND> expr = UnaryExpressionNoPrefix()
1246   {
1247     if (token == null) {
1248       return expr;
1249     }
1250     return token.image + expr;
1251   }
1252 |
1253   (<AT> {buff.append("@");})* expr = UnaryExpressionNoPrefix()
1254   {return buff.append(expr).toString();}
1255 }
1256
1257 String UnaryExpressionNoPrefix() :
1258 {
1259   String expr;
1260   Token token;
1261 }
1262 {
1263   ( token = <PLUS> | token = <MINUS> ) expr = UnaryExpression()
1264   {
1265     return token.image + expr;
1266   }
1267 |
1268   expr = PreIncrementExpression()
1269   {return expr;}
1270 |
1271   expr = PreDecrementExpression()
1272   {return expr;}
1273 |
1274   expr = UnaryExpressionNotPlusMinus()
1275   {return expr;}
1276 }
1277
1278
1279 String PreIncrementExpression() :
1280 {
1281 String expr;
1282 }
1283 {
1284   <INCR> expr = PrimaryExpression()
1285   {return "++"+expr;}
1286 }
1287
1288 String PreDecrementExpression() :
1289 {
1290 String expr;
1291 }
1292 {
1293   <DECR> expr = PrimaryExpression()
1294   {return "--"+expr;}
1295 }
1296
1297 String UnaryExpressionNotPlusMinus() :
1298 {
1299   String expr;
1300 }
1301 {
1302   <BANG> expr = UnaryExpression()
1303   {return "!" + expr;}
1304 |
1305   LOOKAHEAD( <LPAREN> Type() <RPAREN> )
1306   expr = CastExpression()
1307   {return expr;}
1308 |
1309   expr = PostfixExpression()
1310   {return expr;}
1311 |
1312   expr = Literal()
1313   {return expr;}
1314 |
1315   <LPAREN> expr = Expression()<RPAREN>
1316   {return "("+expr+")";}
1317 }
1318
1319 String CastExpression() :
1320 {
1321 final String type, expr;
1322 }
1323 {
1324   <LPAREN> type = Type() <RPAREN> expr = UnaryExpression()
1325   {return "(" + type + ")" + expr;}
1326 }
1327
1328 String PostfixExpression() :
1329 {
1330   String expr;
1331   Token operator = null;
1332 }
1333 {
1334   expr = PrimaryExpression() [ operator = <INCR> | operator = <DECR> ]
1335   {
1336     if (operator == null) {
1337       return expr;
1338     }
1339     return expr + operator.image;
1340   }
1341 }
1342
1343 String PrimaryExpression() :
1344 {
1345   Token identifier;
1346   String expr;
1347   final StringBuffer buff = new StringBuffer();
1348 }
1349 {
1350   LOOKAHEAD(2)
1351   identifier = <IDENTIFIER> <STATICCLASSACCESS> expr = ClassIdentifier()
1352   {buff.append(identifier.image).append("::").append(expr);}
1353   (
1354   expr = PrimarySuffix()
1355   {buff.append(expr);}
1356   )*
1357   {return buff.toString();}
1358 |
1359   expr = PrimaryPrefix()  {buff.append(expr);}
1360   ( expr = PrimarySuffix()  {buff.append(expr);} )*
1361   {return buff.toString();}
1362 |
1363   expr = ArrayDeclarator()
1364   {return "array" + expr;}
1365 }
1366
1367 String ArrayDeclarator() :
1368 {
1369   final String expr;
1370 }
1371 {
1372   <ARRAY> expr = ArrayInitializer()
1373   {return "array" + expr;}
1374 }
1375
1376 String PrimaryPrefix() :
1377 {
1378   String expr;
1379   Token token = null;
1380 }
1381 {
1382   token = <IDENTIFIER>
1383   {return token.image;}
1384 |
1385   <NEW> expr = ClassIdentifier()
1386   {
1387     return "new " + expr;
1388   }
1389 |  
1390   expr = VariableDeclaratorId()
1391   {return expr;}
1392 }
1393
1394 String ClassIdentifier():
1395 {
1396   String expr;
1397   Token token;
1398 }
1399 {
1400   token = <IDENTIFIER>
1401   {return token.image;}
1402 |
1403   expr = VariableDeclaratorId()
1404   {return expr;}
1405 }
1406
1407 String PrimarySuffix() :
1408 {
1409   String expr;
1410 }
1411 {
1412   expr = Arguments()
1413   {return expr;}
1414 |
1415   expr = VariableSuffix()
1416   {return expr;}
1417 }
1418
1419 String VariableSuffix() :
1420 {
1421   String expr = null;
1422 }
1423 {
1424   <CLASSACCESS> expr = VariableName()
1425   {return "->" + expr;}
1426
1427   <LBRACKET> [ expr = Expression() ]
1428   try {
1429     <RBRACKET>
1430   } catch (ParseException e) {
1431     errorMessage = "']' expected";
1432     errorLevel   = ERROR;
1433     throw e;
1434   }
1435   {
1436     if(expr == null) {
1437       return "[]";
1438     }
1439     return "[" + expr + "]";
1440   }
1441 }
1442
1443 String Literal() :
1444 {
1445   String expr;
1446   Token token;
1447 }
1448 {
1449   token = <INTEGER_LITERAL>
1450   {return token.image;}
1451 |
1452   token = <FLOATING_POINT_LITERAL>
1453   {return token.image;}
1454 |
1455   token = <STRING_LITERAL>
1456   {return token.image;}
1457 |
1458   expr = BooleanLiteral()
1459   {return expr;}
1460 |
1461   expr = NullLiteral()
1462   {return expr;}
1463 }
1464
1465 String BooleanLiteral() :
1466 {}
1467 {
1468   <TRUE>
1469   {return "true";}
1470 |
1471   <FALSE>
1472   {return "false";}
1473 }
1474
1475 String NullLiteral() :
1476 {}
1477 {
1478   <NULL>
1479   {return "null";}
1480 }
1481
1482 String Arguments() :
1483 {
1484 String expr = null;
1485 }
1486 {
1487   <LPAREN> [ expr = ArgumentList() ]
1488   try {
1489     <RPAREN>
1490   } catch (ParseException e) {
1491     errorMessage = "')' expected to close the argument list";
1492     errorLevel   = ERROR;
1493     throw e;
1494   }
1495   {
1496   if (expr == null) {
1497     return "()";
1498   }
1499   return "(" + expr + ")";
1500   }
1501 }
1502
1503 String ArgumentList() :
1504 {
1505 String expr;
1506 final StringBuffer buff = new StringBuffer();
1507 }
1508 {
1509   expr = Expression()
1510   {buff.append(expr);}
1511   ( <COMMA>
1512       try {
1513         expr = Expression()
1514       } catch (ParseException e) {
1515         errorMessage = "expression expected after a comma in argument list";
1516         errorLevel   = ERROR;
1517         throw e;
1518       }
1519     {
1520       buff.append(",").append("expr");
1521     }
1522    )*
1523    {return buff.toString();}
1524 }
1525
1526 /*
1527  * Statement syntax follows.
1528  */
1529
1530 void Statement() :
1531 {}
1532 {
1533   LOOKAHEAD(2)
1534   Expression()
1535   try {
1536     (<SEMICOLON> | "?>")
1537   } catch (ParseException e) {
1538     errorMessage = "';' expected";
1539     errorLevel   = ERROR;
1540     throw e;
1541   }
1542 |
1543   LOOKAHEAD(2)
1544   LabeledStatement()
1545 |
1546   Block()
1547 |
1548   EmptyStatement()
1549 |
1550   StatementExpression()
1551   try {
1552     <SEMICOLON>
1553   } catch (ParseException e) {
1554     errorMessage = "';' expected after expression";
1555     errorLevel   = ERROR;
1556     throw e;
1557   }
1558 |
1559   SwitchStatement()
1560 |
1561   IfStatement()
1562 |
1563   WhileStatement()
1564 |
1565   DoStatement()
1566 |
1567   ForStatement()
1568 |
1569   ForeachStatement()
1570 |
1571   BreakStatement()
1572 |
1573   ContinueStatement()
1574 |
1575   ReturnStatement()
1576 |
1577   EchoStatement()
1578 |
1579   [<AT>] IncludeStatement()
1580 |
1581   StaticStatement()
1582 |
1583   GlobalStatement()
1584 }
1585
1586 void IncludeStatement() :
1587 {
1588   String expr;
1589   final int pos = jj_input_stream.bufpos;
1590 }
1591 {
1592   <REQUIRE>
1593   expr = Expression()
1594   {
1595     if (currentSegment != null) {
1596       currentSegment.add(new PHPReqIncDeclaration(currentSegment, "require",pos,expr));
1597     }
1598   }
1599   try {
1600     (<SEMICOLON> | "?>")
1601   } catch (ParseException e) {
1602     errorMessage = "';' expected";
1603     errorLevel   = ERROR;
1604     throw e;
1605   }
1606 |
1607   <REQUIRE_ONCE>
1608   expr = Expression()
1609   {
1610     if (currentSegment != null) {
1611       currentSegment.add(new PHPReqIncDeclaration(currentSegment, "require_once",pos,expr));
1612     }
1613   }
1614   try {
1615     (<SEMICOLON> | "?>")
1616   } catch (ParseException e) {
1617     errorMessage = "';' expected";
1618     errorLevel   = ERROR;
1619     throw e;
1620   }
1621 |
1622   <INCLUDE>
1623   expr = Expression()
1624   {
1625     if (currentSegment != null) {
1626       currentSegment.add(new PHPReqIncDeclaration(currentSegment, "include",pos,expr));
1627     }
1628   }
1629   try {
1630     (<SEMICOLON> | "?>")
1631   } catch (ParseException e) {
1632     errorMessage = "';' expected";
1633     errorLevel   = ERROR;
1634     throw e;
1635   }
1636 |
1637   <INCLUDE_ONCE>
1638   expr = Expression()
1639   {
1640     if (currentSegment != null) {
1641       currentSegment.add(new PHPReqIncDeclaration(currentSegment, "include_once",pos,expr));
1642     }
1643   }
1644   try {
1645     (<SEMICOLON> | "?>")
1646   } catch (ParseException e) {
1647     errorMessage = "';' expected";
1648     errorLevel   = ERROR;
1649     throw e;
1650   }
1651 }
1652
1653 String PrintExpression() :
1654 {
1655   final StringBuffer buff = new StringBuffer("print ");
1656   String expr;
1657 }
1658 {
1659   <PRINT> expr = Expression()
1660   {
1661     buff.append(expr);
1662     return buff.toString();
1663   }
1664 }
1665
1666 void EchoStatement() :
1667 {}
1668 {
1669   <ECHO> Expression() (<COMMA> Expression())*
1670   try {
1671     (<SEMICOLON> | "?>")
1672   } catch (ParseException e) {
1673     errorMessage = "';' expected after 'echo' statement";
1674     errorLevel   = ERROR;
1675     throw e;
1676   }
1677 }
1678
1679 void GlobalStatement() :
1680 {}
1681 {
1682   <GLOBAL> VariableDeclaratorId() (<COMMA> VariableDeclaratorId())*
1683   try {
1684     (<SEMICOLON> | "?>")
1685   } catch (ParseException e) {
1686     errorMessage = "';' expected";
1687     errorLevel   = ERROR;
1688     throw e;
1689   }
1690 }
1691
1692 void StaticStatement() :
1693 {}
1694 {
1695   <STATIC> VariableDeclarator() (<COMMA> VariableDeclarator())*
1696   try {
1697     (<SEMICOLON> | "?>")
1698   } catch (ParseException e) {
1699     errorMessage = "';' expected";
1700     errorLevel   = ERROR;
1701     throw e;
1702   }
1703 }
1704
1705 void LabeledStatement() :
1706 {}
1707 {
1708   <IDENTIFIER> <COLON> Statement()
1709 }
1710
1711 void Block() :
1712 {}
1713 {
1714   try {
1715     <LBRACE>
1716   } catch (ParseException e) {
1717     errorMessage = "'{' expected";
1718     errorLevel   = ERROR;
1719     throw e;
1720   }
1721   ( BlockStatement() )*
1722   <RBRACE>
1723 }
1724
1725 void BlockStatement() :
1726 {}
1727 {
1728   Statement()
1729 |
1730   ClassDeclaration()
1731 |
1732   MethodDeclaration()
1733 }
1734
1735 void LocalVariableDeclaration() :
1736 {}
1737 {
1738   VariableDeclarator() ( <COMMA> VariableDeclarator() )*
1739 }
1740
1741 void EmptyStatement() :
1742 {}
1743 {
1744   <SEMICOLON>
1745 }
1746
1747 void StatementExpression() :
1748 {}
1749 {
1750   PreIncrementExpression()
1751 |
1752   PreDecrementExpression()
1753 |
1754   PrimaryExpression()
1755   [
1756    <INCR>
1757   |
1758     <DECR>
1759   |
1760     AssignmentOperator() Expression()
1761   ]
1762 }
1763
1764 void SwitchStatement() :
1765 {}
1766 {
1767   <SWITCH> <LPAREN> Expression() <RPAREN> <LBRACE>
1768     ( SwitchLabel() ( BlockStatement() )* )*
1769   <RBRACE>
1770 }
1771
1772 void SwitchLabel() :
1773 {}
1774 {
1775   <CASE> Expression() <COLON>
1776 |
1777   <_DEFAULT> <COLON>
1778 }
1779
1780 void IfStatement() :
1781 /*
1782  * The disambiguating algorithm of JavaCC automatically binds dangling
1783  * else's to the innermost if statement.  The LOOKAHEAD specification
1784  * is to tell JavaCC that we know what we are doing.
1785  */
1786 {
1787   Token token;
1788   final int pos = jj_input_stream.bufpos;
1789 }
1790 {
1791   token = <IF> Condition("if") IfStatement0(pos,pos+token.image.length())
1792 }
1793
1794 void Condition(String keyword) :
1795 {}
1796 {
1797   try {
1798     <LPAREN>
1799   } catch (ParseException e) {
1800     errorMessage = "'(' expected after " + keyword + " keyword";
1801     errorLevel   = ERROR;
1802     throw e;
1803   }
1804   Expression()
1805   try {
1806      <RPAREN>
1807   } catch (ParseException e) {
1808     errorMessage = "')' expected after " + keyword + " keyword";
1809     errorLevel   = ERROR;
1810     throw e;
1811   }
1812 }
1813
1814 void IfStatement0(int start,int end) :
1815 {
1816 }
1817 {
1818   <COLON> (Statement())* (ElseIfStatementColon())* [ElseStatementColon()]
1819
1820   {try {
1821   setMarker(fileToParse,
1822             "Ugly syntax detected, you should if () {...} instead of if (): ... endif;",
1823             start,
1824             end,
1825             INFO,
1826             "Line " + token.beginLine);
1827   } catch (CoreException e) {
1828     PHPeclipsePlugin.log(e);
1829   }}
1830   try {
1831     <ENDIF>
1832   } catch (ParseException e) {
1833     errorMessage = "'endif' expected";
1834     errorLevel   = ERROR;
1835     throw e;
1836   }
1837   try {
1838     <SEMICOLON>
1839   } catch (ParseException e) {
1840     errorMessage = "';' expected 'endif' keyword";
1841     errorLevel   = ERROR;
1842     throw e;
1843   }
1844 |
1845   Statement() ( LOOKAHEAD(1) ElseIfStatement() )* [ LOOKAHEAD(1) <ELSE> Statement() ]
1846 }
1847
1848 void ElseIfStatementColon() :
1849 {}
1850 {
1851   <ELSEIF> Condition("elseif") <COLON> (Statement())*
1852 }
1853
1854 void ElseStatementColon() :
1855 {}
1856 {
1857   <ELSE> <COLON> (Statement())*
1858 }
1859
1860 void ElseIfStatement() :
1861 {}
1862 {
1863   <ELSEIF> Condition("elseif") Statement()
1864 }
1865
1866 void WhileStatement() :
1867 {
1868   Token token;
1869   final int pos = jj_input_stream.bufpos;
1870 }
1871 {
1872   token = <WHILE> Condition("while") WhileStatement0(pos,pos + token.image.length())
1873 }
1874
1875 void WhileStatement0(final int start, final int end) :
1876 {}
1877 {
1878   <COLON> (Statement())*
1879   {try {
1880   setMarker(fileToParse,
1881             "Ugly syntax detected, you should while () {...} instead of while (): ... endwhile;",
1882             start,
1883             end,
1884             INFO,
1885             "Line " + token.beginLine);
1886   } catch (CoreException e) {
1887     PHPeclipsePlugin.log(e);
1888   }}
1889   try {
1890     <ENDWHILE>
1891   } catch (ParseException e) {
1892     errorMessage = "'endwhile' expected";
1893     errorLevel   = ERROR;
1894     throw e;
1895   }
1896   try {
1897     (<SEMICOLON> | "?>")
1898   } catch (ParseException e) {
1899     errorMessage = "';' expected after 'endwhile' keyword";
1900     errorLevel   = ERROR;
1901     throw e;
1902   }
1903 |
1904   Statement()
1905 }
1906
1907 void DoStatement() :
1908 {}
1909 {
1910   <DO> Statement() <WHILE> Condition("while")
1911   try {
1912     (<SEMICOLON> | "?>")
1913   } catch (ParseException e) {
1914     errorMessage = "';' expected";
1915     errorLevel   = ERROR;
1916     throw e;
1917   }
1918 }
1919
1920 void ForeachStatement() :
1921 {}
1922 {
1923   <FOREACH>
1924     try {
1925     <LPAREN>
1926   } catch (ParseException e) {
1927     errorMessage = "'(' expected after 'foreach' keyword";
1928     errorLevel   = ERROR;
1929     throw e;
1930   }
1931   try {
1932     Variable()
1933   } catch (ParseException e) {
1934     errorMessage = "variable expected";
1935     errorLevel   = ERROR;
1936     throw e;
1937   }
1938   try {
1939     <AS>
1940   } catch (ParseException e) {
1941     errorMessage = "'as' expected";
1942     errorLevel   = ERROR;
1943     throw e;
1944   }
1945   try {
1946     Variable()
1947   } catch (ParseException e) {
1948     errorMessage = "variable expected";
1949     errorLevel   = ERROR;
1950     throw e;
1951   }
1952   [ <ARRAYASSIGN> Expression() ]
1953   try {
1954     <RPAREN>
1955   } catch (ParseException e) {
1956     errorMessage = "')' expected after 'foreach' keyword";
1957     errorLevel   = ERROR;
1958     throw e;
1959   }
1960   try {
1961   Statement()
1962   } catch (ParseException e) {
1963     if (errorMessage != null) throw e;
1964     errorMessage = "statement expected";
1965     errorLevel   = ERROR;
1966     throw e;
1967   }
1968 }
1969
1970 void ForStatement() :
1971 {
1972 Token token;
1973 final int pos = jj_input_stream.bufpos;
1974 }
1975 {
1976   token = <FOR>
1977   try {
1978     <LPAREN>
1979   } catch (ParseException e) {
1980     errorMessage = "'(' expected after 'for' keyword";
1981     errorLevel   = ERROR;
1982     throw e;
1983   }
1984      [ ForInit() ] <SEMICOLON> [ Expression() ] <SEMICOLON> [ ForUpdate() ] <RPAREN>
1985     (
1986       Statement()
1987     |
1988       <COLON> (Statement())*
1989       {
1990         try {
1991         setMarker(fileToParse,
1992                   "Ugly syntax detected, you should for () {...} instead of for (): ... endfor;",
1993                   pos,
1994                   pos+token.image.length(),
1995                   INFO,
1996                   "Line " + token.beginLine);
1997         } catch (CoreException e) {
1998           PHPeclipsePlugin.log(e);
1999         }
2000       }
2001       try {
2002         <ENDFOR>
2003       } catch (ParseException e) {
2004         errorMessage = "'endfor' expected";
2005         errorLevel   = ERROR;
2006         throw e;
2007       }
2008       try {
2009         <SEMICOLON>
2010       } catch (ParseException e) {
2011         errorMessage = "';' expected 'endfor' keyword";
2012         errorLevel   = ERROR;
2013         throw e;
2014       }
2015     )
2016 }
2017
2018 void ForInit() :
2019 {}
2020 {
2021   LOOKAHEAD(LocalVariableDeclaration())
2022   LocalVariableDeclaration()
2023 |
2024   StatementExpressionList()
2025 }
2026
2027 void StatementExpressionList() :
2028 {}
2029 {
2030   StatementExpression() ( <COMMA> StatementExpression() )*
2031 }
2032
2033 void ForUpdate() :
2034 {}
2035 {
2036   StatementExpressionList()
2037 }
2038
2039 void BreakStatement() :
2040 {}
2041 {
2042   <BREAK> [ <IDENTIFIER> ] <SEMICOLON>
2043 }
2044
2045 void ContinueStatement() :
2046 {}
2047 {
2048   <CONTINUE> [ <IDENTIFIER> ] <SEMICOLON>
2049 }
2050
2051 void ReturnStatement() :
2052 {}
2053 {
2054   <RETURN> [ Expression() ] <SEMICOLON>
2055 }