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