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