misc
[phpeclipse.git] / net.sourceforge.phpeclipse / src / test / PHPParser.jj
1
2 options {
3   LOOKAHEAD = 1;
4   CHOICE_AMBIGUITY_CHECK = 2;
5   OTHER_AMBIGUITY_CHECK = 1;
6   STATIC = true;
7   DEBUG_PARSER = false;
8   DEBUG_LOOKAHEAD = false;
9   DEBUG_TOKEN_MANAGER = false;
10   OPTIMIZE_TOKEN_MANAGER = false;
11   ERROR_REPORTING = true;
12   JAVA_UNICODE_ESCAPE = false;
13   UNICODE_INPUT = false;
14   IGNORE_CASE = true;
15   USER_TOKEN_MANAGER = false;
16   USER_CHAR_STREAM = false;
17   BUILD_PARSER = true;
18   BUILD_TOKEN_MANAGER = true;
19   SANITY_CHECK = true;
20   FORCE_LA_CHECK = false;
21   COMMON_TOKEN_ACTION = true;
22 }
23
24 PARSER_BEGIN(PHPParser)
25 package test;
26
27 import org.eclipse.core.resources.IFile;
28 import org.eclipse.core.resources.IMarker;
29 import org.eclipse.core.runtime.CoreException;
30 import org.eclipse.ui.texteditor.MarkerUtilities;
31 import org.eclipse.jface.preference.IPreferenceStore;
32
33 import java.util.Hashtable;
34 import java.util.ArrayList;
35 import java.io.StringReader;
36 import java.io.*;
37 import java.text.MessageFormat;
38
39 import net.sourceforge.phpeclipse.actions.PHPStartApacheAction;
40 import net.sourceforge.phpeclipse.PHPeclipsePlugin;
41 import net.sourceforge.phpdt.internal.compiler.ast.*;
42 import net.sourceforge.phpdt.internal.compiler.parser.OutlineableWithChildren;
43 import net.sourceforge.phpdt.internal.compiler.parser.Outlineable;
44 import net.sourceforge.phpdt.internal.compiler.parser.PHPOutlineInfo;
45 import net.sourceforge.phpdt.internal.corext.Assert;
46
47 /**
48  * A new php parser.
49  * This php parser is inspired by the Java 1.2 grammar example
50  * given with JavaCC. You can get JavaCC at http://www.webgain.com
51  * You can test the parser with the PHPParserTestCase2.java
52  * @author Matthieu Casanova
53  */
54 public final class PHPParser extends PHPParserSuperclass {
55
56 //todo : fix the variables names bug
57 //todo : handle tilde operator
58
59
60   /** The current segment. */
61   private static OutlineableWithChildren currentSegment;
62
63   private static final String PARSE_ERROR_STRING = "Parse error"; //$NON-NLS-1$
64   private static final String PARSE_WARNING_STRING = "Warning"; //$NON-NLS-1$
65   static PHPOutlineInfo outlineInfo;
66
67   /** The error level of the current ParseException. */
68   private static int errorLevel = ERROR;
69   /** The message of the current ParseException. If it's null it's because the parse exception wasn't handled */
70   private static String errorMessage;
71
72   private static int errorStart = -1;
73   private static int errorEnd = -1;
74   private static PHPDocument phpDocument;
75
76   private static final String SYNTAX_ERROR_CHAR = "syntax error";
77   /**
78    * The point where html starts.
79    * It will be used by the token manager to create HTMLCode objects
80    */
81   public static int htmlStart;
82
83   //ast stack
84   private final static int AstStackIncrement = 100;
85   /** The stack of node. */
86   private static AstNode[] nodes;
87   /** The cursor in expression stack. */
88   private static int nodePtr;
89
90   private static final boolean PARSER_DEBUG = true;
91
92   public final void setFileToParse(final IFile fileToParse) {
93     PHPParser.fileToParse = fileToParse;
94   }
95
96   public PHPParser() {
97   }
98
99   public PHPParser(final IFile fileToParse) {
100     this(new StringReader(""));
101     PHPParser.fileToParse = fileToParse;
102   }
103
104   public static final void phpParserTester(final String strEval) throws ParseException {
105     final StringReader stream = new StringReader(strEval);
106     if (jj_input_stream == null) {
107       jj_input_stream = new SimpleCharStream(stream, 1, 1);
108     }
109     ReInit(new StringReader(strEval));
110     init();
111     phpDocument = new PHPDocument(null,"_root".toCharArray());
112     currentSegment = phpDocument;
113     outlineInfo = new PHPOutlineInfo(null, currentSegment);
114     PHPParserTokenManager.SwitchTo(PHPParserTokenManager.PHPPARSING);
115     phpTest();
116   }
117
118   public static final void htmlParserTester(final File fileName) throws FileNotFoundException, ParseException {
119     final Reader stream = new FileReader(fileName);
120     if (jj_input_stream == null) {
121       jj_input_stream = new SimpleCharStream(stream, 1, 1);
122     }
123     ReInit(stream);
124     init();
125     phpDocument = new PHPDocument(null,"_root".toCharArray());
126     currentSegment = phpDocument;
127     outlineInfo = new PHPOutlineInfo(null, currentSegment);
128     phpFile();
129   }
130
131   public static final void htmlParserTester(final String strEval) throws ParseException {
132     final StringReader stream = new StringReader(strEval);
133     if (jj_input_stream == null) {
134       jj_input_stream = new SimpleCharStream(stream, 1, 1);
135     }
136     ReInit(stream);
137     init();
138     phpDocument = new PHPDocument(null,"_root".toCharArray());
139     currentSegment = phpDocument;
140     outlineInfo = new PHPOutlineInfo(null, currentSegment);
141     phpFile();
142   }
143
144   /**
145    * Reinitialize the parser.
146    */
147   private static final void init() {
148     nodes = new AstNode[AstStackIncrement];
149     nodePtr = -1;
150     htmlStart = 0;
151   }
152
153   /**
154    * Add an php node on the stack.
155    * @param node the node that will be added to the stack
156    */
157   private static final void pushOnAstNodes(final AstNode node) {
158     try {
159       nodes[++nodePtr] = node;
160     } catch (IndexOutOfBoundsException e) {
161       final int oldStackLength = nodes.length;
162       final AstNode[] oldStack = nodes;
163       nodes = new AstNode[oldStackLength + AstStackIncrement];
164       System.arraycopy(oldStack, 0, nodes, 0, oldStackLength);
165       nodePtr = oldStackLength;
166       nodes[nodePtr] = node;
167     }
168   }
169
170   public final PHPOutlineInfo parseInfo(final Object parent, final String s) {
171     phpDocument = new PHPDocument(parent,"_root".toCharArray());
172     currentSegment = phpDocument;
173     outlineInfo = new PHPOutlineInfo(parent, currentSegment);
174     final StringReader stream = new StringReader(s);
175     if (jj_input_stream == null) {
176       jj_input_stream = new SimpleCharStream(stream, 1, 1);
177     }
178     ReInit(stream);
179     init();
180     try {
181       parse();
182       phpDocument.nodes = new AstNode[nodes.length];
183       System.arraycopy(nodes,0,phpDocument.nodes,0,nodes.length);
184       if (PHPeclipsePlugin.DEBUG) {
185         PHPeclipsePlugin.log(1,phpDocument.toString());
186       }
187     } catch (ParseException e) {
188       processParseException(e);
189     }
190     return outlineInfo;
191   }
192
193   private static void processParseExceptionDebug(final ParseException e) throws ParseException {
194     if (PARSER_DEBUG) {
195       throw e;
196     }
197     processParseException(e);
198   }
199   /**
200    * This method will process the parse exception.
201    * If the error message is null, the parse exception wasn't catched and a trace is written in the log
202    * @param e the ParseException
203    */
204   private static void processParseException(final ParseException e) {
205     if (errorMessage == null) {
206       PHPeclipsePlugin.log(e);
207       errorMessage = "this exception wasn't handled by the parser please tell us how to reproduce it";
208       errorStart = e.currentToken.sourceStart;
209       errorEnd   = e.currentToken.sourceEnd;
210     }
211     setMarker(e);
212     errorMessage = null;
213   //  if (PHPeclipsePlugin.DEBUG) PHPeclipsePlugin.log(e);
214   }
215
216   /**
217    * Create marker for the parse error.
218    * @param e the ParseException
219    */
220   private static void setMarker(final ParseException e) {
221     try {
222       if (errorStart == -1) {
223         setMarker(fileToParse,
224                   errorMessage,
225                   e.currentToken.sourceStart,
226                   e.currentToken.sourceEnd,
227                   errorLevel,
228                   "Line " + e.currentToken.beginLine);
229       } else {
230         setMarker(fileToParse,
231                   errorMessage,
232                   errorStart,
233                   errorEnd,
234                   errorLevel,
235                   "Line " + e.currentToken.beginLine);
236         errorStart = -1;
237         errorEnd = -1;
238       }
239     } catch (CoreException e2) {
240       PHPeclipsePlugin.log(e2);
241     }
242   }
243
244   private static void scanLine(final String output,
245                                final IFile file,
246                                final int indx,
247                                final int brIndx) throws CoreException {
248     String current;
249     final StringBuffer lineNumberBuffer = new StringBuffer(10);
250     char ch;
251     current = output.substring(indx, brIndx);
252
253     if (current.indexOf(PARSE_WARNING_STRING) != -1 || current.indexOf(PARSE_ERROR_STRING) != -1) {
254       final int onLine = current.indexOf("on line <b>");
255       if (onLine != -1) {
256         lineNumberBuffer.delete(0, lineNumberBuffer.length());
257         for (int i = onLine; i < current.length(); i++) {
258           ch = current.charAt(i);
259           if ('0' <= ch && '9' >= ch) {
260             lineNumberBuffer.append(ch);
261           }
262         }
263
264         final int lineNumber = Integer.parseInt(lineNumberBuffer.toString());
265
266         final Hashtable attributes = new Hashtable();
267
268         current = current.replaceAll("\n", "");
269         current = current.replaceAll("<b>", "");
270         current = current.replaceAll("</b>", "");
271         MarkerUtilities.setMessage(attributes, current);
272
273         if (current.indexOf(PARSE_ERROR_STRING) != -1)
274           attributes.put(IMarker.SEVERITY, new Integer(IMarker.SEVERITY_ERROR));
275         else if (current.indexOf(PARSE_WARNING_STRING) != -1)
276           attributes.put(IMarker.SEVERITY, new Integer(IMarker.SEVERITY_WARNING));
277         else
278           attributes.put(IMarker.SEVERITY, new Integer(IMarker.SEVERITY_INFO));
279         MarkerUtilities.setLineNumber(attributes, lineNumber);
280         MarkerUtilities.createMarker(file, attributes, IMarker.PROBLEM);
281       }
282     }
283   }
284
285   public final void parse(final String s) {
286     final StringReader stream = new StringReader(s);
287     if (jj_input_stream == null) {
288       jj_input_stream = new SimpleCharStream(stream, 1, 1);
289     }
290     ReInit(stream);
291     init();
292     try {
293       parse();
294     } catch (ParseException e) {
295       processParseException(e);
296     }
297   }
298
299   /**
300    * Call the php parse command ( php -l -f &lt;filename&gt; )
301    * and create markers according to the external parser output
302    */
303   public static void phpExternalParse(final IFile file) {
304     final IPreferenceStore store = PHPeclipsePlugin.getDefault().getPreferenceStore();
305     final String filename = file.getLocation().toString();
306
307     final String[] arguments = { filename };
308     final MessageFormat form = new MessageFormat(store.getString(PHPeclipsePlugin.EXTERNAL_PARSER_PREF));
309     final String command = form.format(arguments);
310
311     final String parserResult = PHPStartApacheAction.getParserOutput(command, "External parser: ");
312
313     try {
314       // parse the buffer to find the errors and warnings
315       createMarkers(parserResult, file);
316     } catch (CoreException e) {
317       PHPeclipsePlugin.log(e);
318     }
319   }
320
321   /**
322    * Put a new html block in the stack.
323    */
324   public static final void createNewHTMLCode() {
325     final int currentPosition = token.sourceStart;
326     if (currentPosition == htmlStart ||
327           currentPosition > SimpleCharStream.currentBuffer.length()) {
328       return;
329     }
330     final char[] chars = SimpleCharStream.currentBuffer.substring(htmlStart,currentPosition+1).toCharArray();
331     pushOnAstNodes(new HTMLCode(chars, htmlStart,currentPosition));
332   }
333
334   /** Create a new task. */
335   public static final void createNewTask() {
336     final int currentPosition = token.sourceStart;
337     final String  todo = SimpleCharStream.currentBuffer.substring(currentPosition-3,
338                                                                   SimpleCharStream.currentBuffer.indexOf("\n",
339                                                                                                          currentPosition)-1);
340     if (!PARSER_DEBUG) {
341       try {
342         setMarker(fileToParse,
343                   todo,
344                   SimpleCharStream.getBeginLine(),
345                   TASK,
346                   "Line "+SimpleCharStream.getBeginLine());
347       } catch (CoreException e) {
348         PHPeclipsePlugin.log(e);
349       }
350     }
351   }
352
353   private static final void parse() throws ParseException {
354           phpFile();
355   }
356 }
357
358 PARSER_END(PHPParser)
359
360 TOKEN_MGR_DECLS:
361 {
362   // CommonTokenAction: use the begins/ends fields added to the Jack
363   // CharStream class to set corresponding fields in each Token (which was
364   // also extended with new fields). By default Jack doesn't supply absolute
365   // offsets, just line/column offsets
366   static void CommonTokenAction(Token t) {
367     t.sourceStart = input_stream.beginOffset;
368     t.sourceEnd = input_stream.endOffset;
369   } // CommonTokenAction
370 } // TOKEN_MGR_DECLS
371
372 <DEFAULT> TOKEN :
373 {
374   <PHPSTARTSHORT : "<?">    {PHPParser.createNewHTMLCode();} : PHPPARSING
375 | <PHPSTARTLONG  : "<?php"> {PHPParser.createNewHTMLCode();} : PHPPARSING
376 | <PHPECHOSTART  : "<?=">   {PHPParser.createNewHTMLCode();} : PHPPARSING
377 }
378
379 <PHPPARSING, IN_SINGLE_LINE_COMMENT> TOKEN :
380 {
381   <PHPEND :"?>"> {PHPParser.htmlStart = PHPParser.token.sourceEnd;} : DEFAULT
382 }
383
384 /* Skip any character if we are not in php mode */
385 <DEFAULT> SKIP :
386 {
387  < ~[] >
388 }
389
390
391 /* WHITE SPACE */
392 <PHPPARSING> SKIP :
393 {
394   " "
395 | "\t"
396 | "\n"
397 | "\r"
398 | "\f"
399 }
400
401 /* COMMENTS */
402 <PHPPARSING> SPECIAL_TOKEN :
403 {
404   "//" : IN_SINGLE_LINE_COMMENT
405 | "#"  : IN_SINGLE_LINE_COMMENT
406 | <"/**" ~["/"]> { input_stream.backup(1); } : IN_FORMAL_COMMENT
407 | "/*" : IN_MULTI_LINE_COMMENT
408 }
409
410 <IN_SINGLE_LINE_COMMENT> SPECIAL_TOKEN :
411 {
412   <SINGLE_LINE_COMMENT: "\n" | "\r" | "\r\n" > : PHPPARSING
413 | < ~[] >
414 }
415
416 <IN_SINGLE_LINE_COMMENT,IN_FORMAL_COMMENT,IN_MULTI_LINE_COMMENT> SPECIAL_TOKEN :
417 {
418  "todo" {PHPParser.createNewTask();}
419 }
420
421 <IN_FORMAL_COMMENT> SPECIAL_TOKEN :
422 {
423   "*/" : PHPPARSING
424 }
425
426 <IN_MULTI_LINE_COMMENT> SPECIAL_TOKEN :
427 {
428   "*/" : PHPPARSING
429 }
430
431 <IN_SINGLE_LINE_COMMENT,IN_FORMAL_COMMENT,IN_MULTI_LINE_COMMENT>
432 MORE :
433 {
434   < ~[] >
435 }
436
437 /* KEYWORDS */
438 <PHPPARSING> TOKEN :
439 {
440   <CLASS    : "class">
441 | <FUNCTION : "function">
442 | <VAR      : "var">
443 | <IF       : "if">
444 | <ELSEIF   : "elseif">
445 | <ELSE     : "else">
446 | <ARRAY    : "array">
447 | <BREAK    : "break">
448 | <LIST     : "list">
449 }
450
451 /* LANGUAGE CONSTRUCT */
452 <PHPPARSING> TOKEN :
453 {
454   <PRINT              : "print">
455 | <ECHO               : "echo">
456 | <INCLUDE            : "include">
457 | <REQUIRE            : "require">
458 | <INCLUDE_ONCE       : "include_once">
459 | <REQUIRE_ONCE       : "require_once">
460 | <GLOBAL             : "global">
461 | <DEFINE             : "define">
462 | <STATIC             : "static">
463 | <CLASSACCESS        : "->">
464 | <STATICCLASSACCESS  : "::">
465 | <ARRAYASSIGN        : "=>">
466 }
467
468 /* RESERVED WORDS AND LITERALS */
469
470 <PHPPARSING> TOKEN :
471 {
472   <CASE     : "case">
473 | <CONST    : "const">
474 | <CONTINUE : "continue">
475 | <_DEFAULT : "default">
476 | <DO       : "do">
477 | <EXTENDS  : "extends">
478 | <FOR      : "for">
479 | <GOTO     : "goto">
480 | <NEW      : "new">
481 | <NULL     : "null">
482 | <RETURN   : "return">
483 | <SUPER    : "super">
484 | <SWITCH   : "switch">
485 | <THIS     : "this">
486 | <TRUE     : "true">
487 | <FALSE    : "false">
488 | <WHILE    : "while">
489 | <ENDWHILE : "endwhile">
490 | <ENDSWITCH: "endswitch">
491 | <ENDIF    : "endif">
492 | <ENDFOR   : "endfor">
493 | <FOREACH  : "foreach">
494 | <AS       : "as" >
495 }
496
497 /* TYPES */
498 <PHPPARSING> TOKEN :
499 {
500   <STRING  : "string">
501 | <OBJECT  : "object">
502 | <BOOL    : "bool">
503 | <BOOLEAN : "boolean">
504 | <REAL    : "real">
505 | <DOUBLE  : "double">
506 | <FLOAT   : "float">
507 | <INT     : "int">
508 | <INTEGER : "integer">
509 }
510
511 //Misc token
512 <PHPPARSING> TOKEN :
513 {
514   <AT                 : "@">
515 | <DOLLAR             : "$">
516 | <BANG               : "!">
517 | <TILDE              : "~">
518 | <HOOK               : "?">
519 | <COLON              : ":">
520 }
521
522 /* OPERATORS */
523 <PHPPARSING> TOKEN :
524 {
525   <OR_OR              : "||">
526 | <AND_AND            : "&&">
527 | <PLUS_PLUS          : "++">
528 | <MINUS_MINUS        : "--">
529 | <PLUS               : "+">
530 | <MINUS              : "-">
531 | <STAR               : "*">
532 | <SLASH              : "/">
533 | <BIT_AND            : "&">
534 | <BIT_OR             : "|">
535 | <XOR                : "^">
536 | <REMAINDER          : "%">
537 | <LSHIFT             : "<<">
538 | <RSIGNEDSHIFT       : ">>">
539 | <RUNSIGNEDSHIFT     : ">>>">
540 | <_ORL               : "OR">
541 | <_ANDL              : "AND">
542 }
543
544 /* LITERALS */
545 <PHPPARSING> TOKEN :
546 {
547   <INTEGER_LITERAL:
548         <DECIMAL_LITERAL> (["l","L"])?
549       | <HEX_LITERAL> (["l","L"])?
550       | <OCTAL_LITERAL> (["l","L"])?
551   >
552 |
553   <#DECIMAL_LITERAL: ["1"-"9"] (["0"-"9"])* >
554 |
555   <#HEX_LITERAL: "0" ["x","X"] (["0"-"9","a"-"f","A"-"F"])+ >
556 |
557   <#OCTAL_LITERAL: "0" (["0"-"7"])* >
558 |
559   <FLOATING_POINT_LITERAL:
560         (["0"-"9"])+ "." (["0"-"9"])* (<EXPONENT>)? (["f","F","d","D"])?
561       | "." (["0"-"9"])+ (<EXPONENT>)? (["f","F","d","D"])?
562       | (["0"-"9"])+ <EXPONENT> (["f","F","d","D"])?
563       | (["0"-"9"])+ (<EXPONENT>)? ["f","F","d","D"]
564   >
565 |
566   <#EXPONENT: ["e","E"] (["+","-"])? (["0"-"9"])+ >
567 |
568   <STRING_LITERAL: (<STRING_1> | <STRING_2> | <STRING_3>)>
569 |   <STRING_1: "\"" ( ~["\"","\\"] | "\\" ~[] )* "\"">
570 |   <STRING_2: "'"  ( ~["'","\\"]  | "\\" ~[] )* "'">
571 |   <STRING_3: "`"  ( ~["`","\\"]  | "\\" ~[] )* "`">
572 }
573
574 /* IDENTIFIERS */
575
576 <PHPPARSING> TOKEN :
577 {
578   <IDENTIFIER: (<LETTER>|<SPECIAL>) (<LETTER>|<DIGIT>|<SPECIAL>)* >
579 |
580   < #LETTER:
581       ["a"-"z"] | ["A"-"Z"]
582   >
583 |
584   < #DIGIT:
585       ["0"-"9"]
586   >
587 |
588   < #SPECIAL:
589     "_" | ["\u007f"-"\u00ff"]
590   >
591 }
592
593 /* SEPARATORS */
594
595 <PHPPARSING> TOKEN :
596 {
597   <LPAREN    : "(">
598 | <RPAREN    : ")">
599 | <LBRACE    : "{">
600 | <RBRACE    : "}">
601 | <LBRACKET  : "[">
602 | <RBRACKET  : "]">
603 | <SEMICOLON : ";">
604 | <COMMA     : ",">
605 | <DOT       : ".">
606 }
607
608
609 /* COMPARATOR */
610 <PHPPARSING> TOKEN :
611 {
612   <GT                 : ">">
613 | <LT                 : "<">
614 | <EQUAL_EQUAL        : "==">
615 | <LE                 : "<=">
616 | <GE                 : ">=">
617 | <NOT_EQUAL          : "!=">
618 | <DIF                : "<>">
619 | <BANGDOUBLEEQUAL    : "!==">
620 | <TRIPLEEQUAL        : "===">
621 }
622
623 /* ASSIGNATION */
624 <PHPPARSING> TOKEN :
625 {
626   <ASSIGN             : "=">
627 | <PLUSASSIGN         : "+=">
628 | <MINUSASSIGN        : "-=">
629 | <STARASSIGN         : "*=">
630 | <SLASHASSIGN        : "/=">
631 | <ANDASSIGN          : "&=">
632 | <ORASSIGN           : "|=">
633 | <XORASSIGN          : "^=">
634 | <DOTASSIGN          : ".=">
635 | <REMASSIGN          : "%=">
636 | <TILDEEQUAL         : "~=">
637 | <LSHIFTASSIGN       : "<<=">
638 | <RSIGNEDSHIFTASSIGN : ">>=">
639 }
640
641 <PHPPARSING> TOKEN :
642 {
643   <DOLLAR_ID: <DOLLAR> <IDENTIFIER>>
644 }
645
646 void phpTest() :
647 {}
648 {
649   Php()
650   <EOF>
651 }
652
653 void phpFile() :
654 {}
655 {
656   try {
657     (PhpBlock())*
658     {PHPParser.createNewHTMLCode();}
659   } catch (TokenMgrError e) {
660     PHPeclipsePlugin.log(e);
661     errorStart   = SimpleCharStream.getPosition();
662     errorEnd     = errorStart + 1;
663     errorMessage = e.getMessage();
664     errorLevel   = ERROR;
665     throw generateParseException();
666   }
667 }
668
669 /**
670  * A php block is a <?= expression [;]?>
671  * or <?php somephpcode ?>
672  * or <? somephpcode ?>
673  */
674 void PhpBlock() :
675 {
676   final PHPEchoBlock phpEchoBlock;
677   final Token token;
678 }
679 {
680   phpEchoBlock = phpEchoBlock()
681   {pushOnAstNodes(phpEchoBlock);}
682 |
683   [   <PHPSTARTLONG>
684     | token = <PHPSTARTSHORT>
685     {try {
686       setMarker(fileToParse,
687                 "You should use '<?php' instead of '<?' it will avoid some problems with XML",
688                 token.sourceStart,
689                 token.sourceEnd,
690                 INFO,
691                 "Line " + token.beginLine);
692     } catch (CoreException e) {
693       PHPeclipsePlugin.log(e);
694     }}
695   ]
696   Php()
697   try {
698     <PHPEND>
699   } catch (ParseException e) {
700     errorMessage = "'?>' expected";
701     errorLevel   = ERROR;
702     errorStart = SimpleCharStream.getPosition() - e.currentToken.next.image.length() + 1;
703     errorEnd   = SimpleCharStream.getPosition() + 1;
704     processParseExceptionDebug(e);
705   }
706 }
707
708 PHPEchoBlock phpEchoBlock() :
709 {
710   final Expression expr;
711   final PHPEchoBlock echoBlock;
712   final Token token, token2;
713 }
714 {
715   token = <PHPECHOSTART> expr = Expression() [ <SEMICOLON> ] token2 = <PHPEND>
716   {
717   echoBlock = new PHPEchoBlock(expr,token.sourceStart,token2.sourceEnd);
718   pushOnAstNodes(echoBlock);
719   return echoBlock;}
720 }
721
722 void Php() :
723 {}
724 {
725   (BlockStatement())*
726 }
727
728 ClassDeclaration ClassDeclaration() :
729 {
730   final ClassDeclaration classDeclaration;
731   Token className = null;
732   final Token superclassName, token;
733   String classNameImage = SYNTAX_ERROR_CHAR;
734   String superclassNameImage = null;
735 }
736 {
737   token = <CLASS>
738   try {
739     className = <IDENTIFIER>
740     {classNameImage = className.image;}
741   } catch (ParseException e) {
742     errorMessage = "unexpected token : '"+ e.currentToken.next.image +"', identifier expected";
743     errorLevel   = ERROR;
744     errorStart   = SimpleCharStream.getPosition() - e.currentToken.next.image.length() + 1;
745     errorEnd     = SimpleCharStream.getPosition() + 1;
746     processParseExceptionDebug(e);
747   }
748   [
749     <EXTENDS>
750     try {
751       superclassName = <IDENTIFIER>
752       {superclassNameImage = superclassName.image;}
753     } catch (ParseException e) {
754       errorMessage = "unexpected token : '"+ e.currentToken.next.image +"', identifier expected";
755       errorLevel   = ERROR;
756       errorStart = SimpleCharStream.getPosition() - e.currentToken.next.image.length() + 1;
757       errorEnd   = SimpleCharStream.getPosition() + 1;
758       processParseExceptionDebug(e);
759       superclassNameImage = SYNTAX_ERROR_CHAR;
760     }
761   ]
762   {
763     int start, end;
764     if (className == null) {
765       start = token.sourceStart;
766       end = token.sourceEnd;
767     } else {
768       start = className.sourceStart;
769       end = className.sourceEnd;
770     }
771     if (superclassNameImage == null) {
772
773       classDeclaration = new ClassDeclaration(currentSegment,
774                                               classNameImage,
775                                               start,
776                                               end);
777     } else {
778       classDeclaration = new ClassDeclaration(currentSegment,
779                                               classNameImage,
780                                               superclassNameImage,
781                                               start,
782                                               end);
783     }
784       currentSegment.add(classDeclaration);
785       currentSegment = classDeclaration;
786   }
787   ClassBody(classDeclaration)
788   {currentSegment = (OutlineableWithChildren) currentSegment.getParent();
789    classDeclaration.sourceEnd = SimpleCharStream.getPosition();
790    pushOnAstNodes(classDeclaration);
791    return classDeclaration;}
792 }
793
794 void ClassBody(final ClassDeclaration classDeclaration) :
795 {}
796 {
797   try {
798     <LBRACE>
799   } catch (ParseException e) {
800     errorMessage = "unexpected token : '"+ e.currentToken.next.image + "'. '{' expected";
801     errorLevel   = ERROR;
802     errorStart = SimpleCharStream.getPosition() - e.currentToken.next.image.length() + 1;
803     errorEnd   = SimpleCharStream.getPosition() + 1;
804     processParseExceptionDebug(e);
805   }
806   ( ClassBodyDeclaration(classDeclaration) )*
807   try {
808     <RBRACE>
809   } catch (ParseException e) {
810     errorMessage = "unexpected token : '"+ e.currentToken.next.image +"'. 'var', 'function' or '}' expected";
811     errorLevel   = ERROR;
812     errorStart = SimpleCharStream.getPosition() - e.currentToken.next.image.length() + 1;
813     errorEnd   = SimpleCharStream.getPosition() + 1;
814     processParseExceptionDebug(e);
815   }
816 }
817
818 /**
819  * A class can contain only methods and fields.
820  */
821 void ClassBodyDeclaration(final ClassDeclaration classDeclaration) :
822 {
823   final MethodDeclaration method;
824   final FieldDeclaration field;
825 }
826 {
827   method = MethodDeclaration() {method.analyzeCode();
828                                 classDeclaration.addMethod(method);}
829 | field = FieldDeclaration()   {classDeclaration.addField(field);}
830 }
831
832 /**
833  * A class field declaration : it's var VariableDeclarator() (, VariableDeclarator())*;.
834  * it is only used by ClassBodyDeclaration()
835  */
836 FieldDeclaration FieldDeclaration() :
837 {
838   VariableDeclaration variableDeclaration;
839   final VariableDeclaration[] list;
840   final ArrayList arrayList = new ArrayList();
841   final Token token;
842   Token token2 = null;
843 }
844 {
845   token = <VAR> variableDeclaration = VariableDeclaratorNoSuffix()
846   {arrayList.add(variableDeclaration);
847    outlineInfo.addVariable(variableDeclaration.name());}
848   (
849     <COMMA> variableDeclaration = VariableDeclaratorNoSuffix()
850       {arrayList.add(variableDeclaration);
851        outlineInfo.addVariable(variableDeclaration.name());}
852   )*
853   try {
854     token2 = <SEMICOLON>
855   } catch (ParseException e) {
856     errorMessage = "unexpected token : '"+ e.currentToken.next.image +"'. A ';' was expected after variable declaration";
857     errorLevel   = ERROR;
858     errorStart   = SimpleCharStream.getPosition() - e.currentToken.next.image.length() + 1;
859     errorEnd     = SimpleCharStream.getPosition() + 1;
860     processParseExceptionDebug(e);
861   }
862
863   {list = new VariableDeclaration[arrayList.size()];
864    arrayList.toArray(list);
865    int end;
866    if (token2 == null) {
867      end = list[list.length-1].sourceEnd;
868    } else {
869      end = token2.sourceEnd;
870    }
871    return new FieldDeclaration(list,
872                                token.sourceStart,
873                                end,
874                                currentSegment);}
875 }
876
877 /**
878  * a strict variable declarator : there cannot be a suffix here.
879  * It will be used by fields and formal parameters
880  */
881 VariableDeclaration VariableDeclaratorNoSuffix() :
882 {
883   final Token varName;
884   Expression initializer = null;
885   Token assignToken;
886 }
887 {
888   varName = <DOLLAR_ID>
889   [
890     assignToken = <ASSIGN>
891     try {
892       initializer = VariableInitializer()
893     } catch (ParseException e) {
894       errorMessage = "Literal expression expected in variable initializer";
895       errorLevel   = ERROR;
896       errorStart = assignToken.sourceEnd +1;
897       errorEnd   = assignToken.sourceEnd +1;
898       processParseExceptionDebug(e);
899     }
900   ]
901   {
902   if (initializer == null) {
903     return new VariableDeclaration(currentSegment,
904                                    new Variable(varName.image.substring(1),
905                                                 varName.sourceStart+1,
906                                                 varName.sourceEnd+1),
907                                    varName.sourceStart+1,
908                                    varName.sourceEnd+1);
909   }
910   return new VariableDeclaration(currentSegment,
911                                  new Variable(varName.image.substring(1),
912                                               varName.sourceStart+1,
913                                               varName.sourceEnd+1),
914                                  initializer,
915                                  VariableDeclaration.EQUAL,
916                                  varName.sourceStart+1);
917   }
918 }
919
920 /**
921  * this will be used by static statement
922  */
923 VariableDeclaration VariableDeclarator() :
924 {
925   final AbstractVariable variable;
926   Expression initializer = null;
927 }
928 {
929   variable = VariableDeclaratorId()
930   [
931     <ASSIGN>
932     try {
933       initializer = VariableInitializer()
934     } catch (ParseException e) {
935       errorMessage = "Literal expression expected in variable initializer";
936       errorLevel   = ERROR;
937       errorStart = SimpleCharStream.getPosition() - e.currentToken.next.image.length() + 1;
938       errorEnd   = SimpleCharStream.getPosition() + 1;
939       processParseExceptionDebug(e);
940     }
941   ]
942   {
943   if (initializer == null) {
944     return new VariableDeclaration(currentSegment,
945                                    variable,
946                                    variable.sourceStart,
947                                    variable.sourceEnd);
948   }
949     return new VariableDeclaration(currentSegment,
950                                    variable,
951                                    initializer,
952                                    VariableDeclaration.EQUAL,
953                                    variable.sourceStart);
954   }
955 }
956
957 /**
958  * A Variable name.
959  * @return the variable name (with suffix)
960  */
961 AbstractVariable VariableDeclaratorId() :
962 {
963   final Variable var;
964   AbstractVariable expression = null;
965 }
966 {
967   try {
968     var = Variable()
969     (
970       LOOKAHEAD(2)
971       expression = VariableSuffix(var)
972     )*
973     {
974      if (expression == null) {
975        return var;
976      }
977      return expression;
978     }
979   } catch (ParseException e) {
980     errorMessage = "'$' expected for variable identifier";
981     errorLevel   = ERROR;
982     errorStart = SimpleCharStream.getPosition() - e.currentToken.next.image.length() + 1;
983     errorEnd   = SimpleCharStream.getPosition() + 1;
984     throw e;
985   }
986 }
987
988 /**
989  * Return a variablename without the $.
990  * @return a variable name
991  *//*
992 Variable Variable():
993 {
994   final StringBuffer buff;
995   Expression expression = null;
996   final Token token;
997   Variable expr;
998   final int pos;
999 }
1000 {
1001   token = <DOLLAR_ID>
1002   [<LBRACE> expression = Expression() <RBRACE>]
1003   {
1004     if (expression == null) {
1005       return new Variable(token.image.substring(1),
1006                           token.sourceStart+1,
1007                           token.sourceEnd+1);
1008     }
1009     String s = expression.toStringExpression();
1010     buff = new StringBuffer(token.image.length()+s.length()+2);
1011     buff.append(token.image);
1012     buff.append("{");
1013     buff.append(s);
1014     buff.append("}");
1015     s = buff.toString();
1016     return new Variable(s,token.sourceStart+1,token.sourceEnd+1);
1017   }
1018 |
1019   token = <DOLLAR>
1020   expr = VariableName()
1021   {return new Variable(expr,token.sourceStart,expr.sourceEnd);}
1022 }   */
1023
1024 Variable Variable() :
1025 {
1026   Variable variable = null;
1027   final Token token;
1028 }
1029 {
1030  token = <DOLLAR_ID> [variable = Var(token)]
1031   {
1032     if (variable == null) {
1033       return new Variable(token.image.substring(1),token.sourceStart+1,token.sourceEnd+1);
1034     }
1035     final StringBuffer buff = new StringBuffer();
1036     buff.append(token.image.substring(1));
1037     buff.append(variable.toStringExpression());
1038     return new Variable(buff.toString(),token.sourceStart+1,variable.sourceEnd+1);
1039   }
1040 |
1041   token = <DOLLAR> variable = Var(token)
1042   {
1043     return new Variable(variable,token.sourceStart,variable.sourceEnd);
1044   }
1045 }
1046
1047 Variable Var(final Token dollar) :
1048 {
1049   Variable variable = null;
1050   final Token token;
1051   ConstantIdentifier constant;
1052 }
1053 {
1054   token = <DOLLAR_ID> [variable = Var(token)]
1055   {if (variable == null) {
1056      return new Variable(token.image.substring(1),token.sourceStart+1,token.sourceEnd+1);
1057    }
1058    final StringBuffer buff = new StringBuffer();
1059    buff.append(token.image.substring(1));
1060    buff.append(variable.toStringExpression());
1061    return new Variable(buff.toString(),dollar.sourceStart,variable.sourceEnd);
1062    }
1063 |
1064   LOOKAHEAD(<DOLLAR> <DOLLAR>)
1065   token = <DOLLAR> variable = Var(token)
1066   {return new Variable(variable,dollar.sourceStart,variable.sourceEnd);}
1067 |
1068   constant = VariableName()
1069   {return new Variable(constant.name,dollar.sourceStart,constant.sourceEnd);}
1070 }
1071
1072 /**
1073  * A Variable name (without the $)
1074  * @return a variable name String
1075  */
1076 ConstantIdentifier VariableName():
1077 {
1078   final StringBuffer buff;
1079   String expr;
1080   Expression expression = null;
1081   final Token token;
1082   Token token2 = null;
1083 }
1084 {
1085   token = <LBRACE> expression = Expression() token2 = <RBRACE>
1086   {expr = expression.toStringExpression();
1087    buff = new StringBuffer(expr.length()+2);
1088    buff.append("{");
1089    buff.append(expr);
1090    buff.append("}");
1091    expr = buff.toString();
1092    return new ConstantIdentifier(expr,
1093                                  token.sourceStart,
1094                                  token2.sourceEnd);
1095
1096    }
1097 |
1098   token = <IDENTIFIER>
1099   [<LBRACE> expression = Expression() token2 = <RBRACE>]
1100   {
1101     if (expression == null) {
1102       return new ConstantIdentifier(token.image,
1103                                     token.sourceStart,
1104                                     token.sourceEnd);
1105     }
1106     expr = expression.toStringExpression();
1107     buff = new StringBuffer(token.image.length()+expr.length()+2);
1108     buff.append(token.image);
1109     buff.append("{");
1110     buff.append(expr);
1111     buff.append("}");
1112     expr = buff.toString();
1113     return new ConstantIdentifier(expr,
1114                                   token.sourceStart,
1115                                   token2.sourceEnd);
1116   }
1117 /*|
1118   <DOLLAR>
1119   var = VariableName()
1120   {
1121     return new Variable(var,
1122                         var.sourceStart-1,
1123                         var.sourceEnd);
1124   }
1125 |
1126   token = <DOLLAR_ID>
1127   {
1128   return new Variable(token.image,
1129                       token.sourceStart+1,
1130                       token.sourceEnd+1);
1131   } */
1132 }
1133
1134 Expression VariableInitializer() :
1135 {
1136   final Expression expr;
1137   final Token token, token2;
1138 }
1139 {
1140   expr = Literal()
1141   {return expr;}
1142 |
1143   token2 = <MINUS> (token = <INTEGER_LITERAL> | token = <FLOATING_POINT_LITERAL>)
1144   {return new PrefixedUnaryExpression(new NumberLiteral(token),
1145                                       OperatorIds.MINUS,
1146                                       token2.sourceStart);}
1147 |
1148   token2 = <PLUS> (token = <INTEGER_LITERAL> | token = <FLOATING_POINT_LITERAL>)
1149   {return new PrefixedUnaryExpression(new NumberLiteral(token),
1150                                       OperatorIds.PLUS,
1151                                       token2.sourceStart);}
1152 |
1153   expr = ArrayDeclarator()
1154   {return expr;}
1155 |
1156   token = <IDENTIFIER>
1157   {return new ConstantIdentifier(token);}
1158 }
1159
1160 ArrayVariableDeclaration ArrayVariable() :
1161 {
1162 final Expression expr,expr2;
1163 }
1164 {
1165   expr = Expression()
1166   [
1167     <ARRAYASSIGN> expr2 = Expression()
1168     {return new ArrayVariableDeclaration(expr,expr2);}
1169   ]
1170   {return new ArrayVariableDeclaration(expr,SimpleCharStream.getPosition());}
1171 }
1172
1173 ArrayVariableDeclaration[] ArrayInitializer() :
1174 {
1175   ArrayVariableDeclaration expr;
1176   final ArrayList list = new ArrayList();
1177 }
1178 {
1179   <LPAREN>
1180     [
1181       expr = ArrayVariable()
1182       {list.add(expr);}
1183       ( LOOKAHEAD(2) <COMMA> expr = ArrayVariable()
1184       {list.add(expr);}
1185       )*
1186     ]
1187     [
1188       <COMMA> {list.add(null);}
1189     ]
1190   <RPAREN>
1191   {
1192   final ArrayVariableDeclaration[] vars = new ArrayVariableDeclaration[list.size()];
1193   list.toArray(vars);
1194   return vars;}
1195 }
1196
1197 /**
1198  * A Method Declaration.
1199  * <b>function</b> MetodDeclarator() Block()
1200  */
1201 MethodDeclaration MethodDeclaration() :
1202 {
1203   final MethodDeclaration functionDeclaration;
1204   final Block block;
1205   final OutlineableWithChildren seg = currentSegment;
1206   final Token token;
1207 }
1208 {
1209   token = <FUNCTION>
1210   try {
1211     functionDeclaration = MethodDeclarator(token.sourceStart)
1212     {outlineInfo.addVariable(new String(functionDeclaration.name));}
1213   } catch (ParseException e) {
1214     if (errorMessage != null)  throw e;
1215     errorMessage = "unexpected token : '"+ e.currentToken.next.image +"', function identifier expected";
1216     errorLevel   = ERROR;
1217     errorStart = SimpleCharStream.getPosition() - e.currentToken.next.image.length() + 1;
1218     errorEnd   = SimpleCharStream.getPosition() + 1;
1219     throw e;
1220   }
1221   {currentSegment = functionDeclaration;}
1222   block = Block()
1223   {functionDeclaration.statements = block.statements;
1224    currentSegment = seg;
1225    return functionDeclaration;}
1226 }
1227
1228 /**
1229  * A MethodDeclarator.
1230  * [&] IDENTIFIER(parameters ...).
1231  * @return a function description for the outline
1232  */
1233 MethodDeclaration MethodDeclarator(final int start) :
1234 {
1235   Token identifier = null;
1236   Token reference = null;
1237   final Hashtable formalParameters = new Hashtable();
1238   String identifierChar = SYNTAX_ERROR_CHAR;
1239   final int end;
1240 }
1241 {
1242   [reference = <BIT_AND>]
1243   try {
1244     identifier = <IDENTIFIER>
1245     {identifierChar = identifier.image;}
1246   } catch (ParseException e) {
1247     errorMessage = "unexpected token : '"+ e.currentToken.next.image +"', function identifier expected";
1248     errorLevel   = ERROR;
1249     errorStart = SimpleCharStream.getPosition() - e.currentToken.next.image.length() + 1;
1250     errorEnd   = SimpleCharStream.getPosition() + 1;
1251     processParseExceptionDebug(e);
1252   }
1253   end = FormalParameters(formalParameters)
1254   {
1255   int nameStart, nameEnd;
1256   if (identifier == null) {
1257     if (reference == null) {
1258       nameStart = start + 9;
1259       nameEnd = start + 10;
1260     } else {
1261       nameStart = reference.sourceEnd + 1;
1262       nameEnd = reference.sourceEnd + 2;
1263     }
1264   } else {
1265       nameStart = identifier.sourceStart;
1266       nameEnd = identifier.sourceEnd;
1267   }
1268   return new MethodDeclaration(currentSegment,
1269                                identifierChar,
1270                                formalParameters,
1271                                reference != null,
1272                                nameStart,
1273                                nameEnd,
1274                                start,
1275                                end);
1276   }
1277 }
1278
1279 /**
1280  * FormalParameters follows method identifier.
1281  * (FormalParameter())
1282  */
1283 int FormalParameters(final Hashtable parameters) :
1284 {
1285   VariableDeclaration var;
1286   final Token token;
1287   int end;
1288 }
1289 {
1290   try {
1291   <LPAREN>
1292   } catch (ParseException e) {
1293     errorMessage = "unexpected token : '"+ e.currentToken.next.image +"', '(' expected after function identifier";
1294     errorLevel   = ERROR;
1295     errorStart = SimpleCharStream.getPosition() - e.currentToken.next.image.length() + 1;
1296     errorEnd   = SimpleCharStream.getPosition() + 1;
1297     processParseExceptionDebug(e);
1298   }
1299   [
1300     var = FormalParameter()
1301     {parameters.put(new String(var.name()),var);}
1302     (
1303       <COMMA> var = FormalParameter()
1304       {parameters.put(new String(var.name()),var);}
1305     )*
1306   ]
1307   try {
1308     token = <RPAREN>
1309     {end = token.sourceEnd;}
1310   } catch (ParseException e) {
1311     errorMessage = "')' expected";
1312     errorLevel   = ERROR;
1313     errorStart = SimpleCharStream.getPosition() - e.currentToken.next.image.length() + 1;
1314     errorEnd   = SimpleCharStream.getPosition() + 1;
1315     processParseExceptionDebug(e);
1316     end = e.currentToken.sourceStart;
1317   }
1318  {return end;}
1319 }
1320
1321 /**
1322  * A formal parameter.
1323  * $varname[=value] (,$varname[=value])
1324  */
1325 VariableDeclaration FormalParameter() :
1326 {
1327   final VariableDeclaration variableDeclaration;
1328   Token token = null;
1329 }
1330 {
1331   [token = <BIT_AND>] variableDeclaration = VariableDeclaratorNoSuffix()
1332   {
1333     if (token != null) {
1334       variableDeclaration.setReference(true);
1335     }
1336     return variableDeclaration;}
1337 }
1338
1339 ConstantIdentifier Type() :
1340 {final Token token;}
1341 {
1342   token = <STRING>    {return new ConstantIdentifier(token);}
1343 | token = <BOOL>      {return new ConstantIdentifier(token);}
1344 | token = <BOOLEAN>   {return new ConstantIdentifier(token);}
1345 | token = <REAL>      {return new ConstantIdentifier(token);}
1346 | token = <DOUBLE>    {return new ConstantIdentifier(token);}
1347 | token = <FLOAT>     {return new ConstantIdentifier(token);}
1348 | token = <INT>       {return new ConstantIdentifier(token);}
1349 | token = <INTEGER>   {return new ConstantIdentifier(token);}
1350 | token = <OBJECT>    {return new ConstantIdentifier(token);}
1351 }
1352
1353 Expression Expression() :
1354 {
1355   final Expression expr;
1356   Expression initializer = null;
1357   int assignOperator = -1;
1358 }
1359 {
1360   LOOKAHEAD(1)
1361   expr = ConditionalExpression()
1362   [
1363     assignOperator = AssignmentOperator()
1364     try {
1365       initializer = Expression()
1366     } catch (ParseException e) {
1367       if (errorMessage != null) {
1368         throw e;
1369       }
1370       errorMessage = "unexpected token : '"+ e.currentToken.next.image +"', expression expected";
1371       errorLevel   = ERROR;
1372       errorEnd   = SimpleCharStream.getPosition();
1373       throw e;
1374     }
1375   ]
1376   {
1377     if (assignOperator != -1) {// todo : change this, very very bad :(
1378         if (expr instanceof AbstractVariable) {
1379           return new VariableDeclaration(currentSegment,
1380                                          (AbstractVariable) expr,
1381                                          initializer,
1382                                          expr.sourceStart,
1383                                          initializer.sourceEnd);
1384         }
1385         String varName = expr.toStringExpression().substring(1);
1386         return new VariableDeclaration(currentSegment,
1387                                        new Variable(varName,
1388                                                     expr.sourceStart,
1389                                                     expr.sourceEnd),
1390                                        expr.sourceStart,
1391                                        initializer.sourceEnd);
1392     }
1393     return expr;
1394   }
1395 | expr = ExpressionWBang()       {return expr;}
1396 }
1397
1398 Expression ExpressionWBang() :
1399 {
1400   final Expression expr;
1401   final Token token;
1402 }
1403 {
1404   token = <BANG> expr = ExpressionWBang()
1405   {return new PrefixedUnaryExpression(expr,OperatorIds.NOT,token.sourceStart);}
1406 | expr = ExpressionNoBang() {return expr;}
1407 }
1408
1409 Expression ExpressionNoBang() :
1410 {
1411   Expression expr;
1412 }
1413 {
1414   expr = ListExpression()    {return expr;}
1415 |
1416   expr = PrintExpression()   {return expr;}
1417 }
1418
1419 /**
1420  * Any assignement operator.
1421  * @return the assignement operator id
1422  */
1423 int AssignmentOperator() :
1424 {}
1425 {
1426   <ASSIGN>             {return VariableDeclaration.EQUAL;}
1427 | <STARASSIGN>         {return VariableDeclaration.STAR_EQUAL;}
1428 | <SLASHASSIGN>        {return VariableDeclaration.SLASH_EQUAL;}
1429 | <REMASSIGN>          {return VariableDeclaration.REM_EQUAL;}
1430 | <PLUSASSIGN>         {return VariableDeclaration.PLUS_EQUAL;}
1431 | <MINUSASSIGN>        {return VariableDeclaration.MINUS_EQUAL;}
1432 | <LSHIFTASSIGN>       {return VariableDeclaration.LSHIFT_EQUAL;}
1433 | <RSIGNEDSHIFTASSIGN> {return VariableDeclaration.RSIGNEDSHIFT_EQUAL;}
1434 | <ANDASSIGN>          {return VariableDeclaration.AND_EQUAL;}
1435 | <XORASSIGN>          {return VariableDeclaration.XOR_EQUAL;}
1436 | <ORASSIGN>           {return VariableDeclaration.OR_EQUAL;}
1437 | <DOTASSIGN>          {return VariableDeclaration.DOT_EQUAL;}
1438 | <TILDEEQUAL>         {return VariableDeclaration.TILDE_EQUAL;}
1439 }
1440
1441 Expression ConditionalExpression() :
1442 {
1443   final Expression expr;
1444   Expression expr2 = null;
1445   Expression expr3 = null;
1446 }
1447 {
1448   expr = ConditionalOrExpression() [ <HOOK> expr2 = Expression() <COLON> expr3 = ConditionalExpression() ]
1449 {
1450   if (expr3 == null) {
1451     return expr;
1452   }
1453   return new ConditionalExpression(expr,expr2,expr3);
1454 }
1455 }
1456
1457 Expression ConditionalOrExpression() :
1458 {
1459   Expression expr,expr2;
1460   int operator;
1461 }
1462 {
1463   expr = ConditionalAndExpression()
1464   (
1465     (
1466         <OR_OR> {operator = OperatorIds.OR_OR;}
1467       | <_ORL>  {operator = OperatorIds.ORL;}
1468     )
1469     expr2 = ConditionalAndExpression()
1470     {
1471       expr = new BinaryExpression(expr,expr2,operator);
1472     }
1473   )*
1474   {return expr;}
1475 }
1476
1477 Expression ConditionalAndExpression() :
1478 {
1479   Expression expr,expr2;
1480   int operator;
1481 }
1482 {
1483   expr = ConcatExpression()
1484   (
1485   (  <AND_AND> {operator = OperatorIds.AND_AND;}
1486    | <_ANDL>   {operator = OperatorIds.ANDL;})
1487    expr2 = ConcatExpression() {expr = new BinaryExpression(expr,expr2,operator);}
1488   )*
1489   {return expr;}
1490 }
1491
1492 Expression ConcatExpression() :
1493 {
1494   Expression expr,expr2;
1495 }
1496 {
1497   expr = InclusiveOrExpression()
1498   (
1499     <DOT> expr2 = InclusiveOrExpression()
1500     {expr = new BinaryExpression(expr,expr2,OperatorIds.DOT);}
1501   )*
1502   {return expr;}
1503 }
1504
1505 Expression InclusiveOrExpression() :
1506 {
1507   Expression expr,expr2;
1508 }
1509 {
1510   expr = ExclusiveOrExpression()
1511   (<BIT_OR> expr2 = ExclusiveOrExpression()
1512    {expr = new BinaryExpression(expr,expr2,OperatorIds.OR);}
1513   )*
1514   {return expr;}
1515 }
1516
1517 Expression ExclusiveOrExpression() :
1518 {
1519   Expression expr,expr2;
1520 }
1521 {
1522   expr = AndExpression()
1523   (
1524     <XOR> expr2 = AndExpression()
1525     {expr = new BinaryExpression(expr,expr2,OperatorIds.XOR);}
1526   )*
1527   {return expr;}
1528 }
1529
1530 Expression AndExpression() :
1531 {
1532   Expression expr,expr2;
1533 }
1534 {
1535   expr = EqualityExpression()
1536   (
1537     LOOKAHEAD(1)
1538     <BIT_AND> expr2 = EqualityExpression()
1539     {expr = new BinaryExpression(expr,expr2,OperatorIds.AND);}
1540   )*
1541   {return expr;}
1542 }
1543
1544 Expression EqualityExpression() :
1545 {
1546   Expression expr,expr2;
1547   int operator;
1548 }
1549 {
1550   expr = RelationalExpression()
1551   (
1552   (   <EQUAL_EQUAL>      {operator = OperatorIds.EQUAL_EQUAL;}
1553     | <DIF>              {operator = OperatorIds.DIF;}
1554     | <NOT_EQUAL>        {operator = OperatorIds.DIF;}
1555     | <BANGDOUBLEEQUAL>  {operator = OperatorIds.BANG_EQUAL_EQUAL;}
1556     | <TRIPLEEQUAL>      {operator = OperatorIds.EQUAL_EQUAL_EQUAL;}
1557   )
1558   try {
1559     expr2 = RelationalExpression()
1560   } catch (ParseException e) {
1561     if (errorMessage != null) {
1562       throw e;
1563     }
1564     errorMessage = "unexpected token : '"+ e.currentToken.next.image +"', expression expected";
1565     errorLevel   = ERROR;
1566     errorStart = SimpleCharStream.getPosition() - e.currentToken.next.image.length() + 1;
1567     errorEnd   = SimpleCharStream.getPosition() + 1;
1568     throw e;
1569   }
1570   {
1571     expr = new BinaryExpression(expr,expr2,operator);
1572   }
1573   )*
1574   {return expr;}
1575 }
1576
1577 Expression RelationalExpression() :
1578 {
1579   Expression expr,expr2;
1580   int operator;
1581 }
1582 {
1583   expr = ShiftExpression()
1584   (
1585   ( <LT> {operator = OperatorIds.LESS;}
1586   | <GT> {operator = OperatorIds.GREATER;}
1587   | <LE> {operator = OperatorIds.LESS_EQUAL;}
1588   | <GE> {operator = OperatorIds.GREATER_EQUAL;})
1589    expr2 = ShiftExpression()
1590   {expr = new BinaryExpression(expr,expr2,operator);}
1591   )*
1592   {return expr;}
1593 }
1594
1595 Expression ShiftExpression() :
1596 {
1597   Expression expr,expr2;
1598   int operator;
1599 }
1600 {
1601   expr = AdditiveExpression()
1602   (
1603   ( <LSHIFT>         {operator = OperatorIds.LEFT_SHIFT;}
1604   | <RSIGNEDSHIFT>   {operator = OperatorIds.RIGHT_SHIFT;}
1605   | <RUNSIGNEDSHIFT> {operator = OperatorIds.UNSIGNED_RIGHT_SHIFT;})
1606   expr2 = AdditiveExpression()
1607   {expr = new BinaryExpression(expr,expr2,operator);}
1608   )*
1609   {return expr;}
1610 }
1611
1612 Expression AdditiveExpression() :
1613 {
1614   Expression expr,expr2;
1615   int operator;
1616 }
1617 {
1618   expr = MultiplicativeExpression()
1619   (
1620     LOOKAHEAD(1)
1621      ( <PLUS>  {operator = OperatorIds.PLUS;}
1622      | <MINUS> {operator = OperatorIds.MINUS;}
1623   )
1624    expr2 = MultiplicativeExpression()
1625   {expr = new BinaryExpression(expr,expr2,operator);}
1626    )*
1627   {return expr;}
1628 }
1629
1630 Expression MultiplicativeExpression() :
1631 {
1632   Expression expr,expr2;
1633   int operator;
1634 }
1635 {
1636   try {
1637     expr = UnaryExpression()
1638   } catch (ParseException e) {
1639     if (errorMessage != null) throw e;
1640     errorMessage = "unexpected token '"+e.currentToken.next.image+"'";
1641     errorLevel   = ERROR;
1642     errorStart = SimpleCharStream.getPosition() - e.currentToken.next.image.length() + 1;
1643     errorEnd   = SimpleCharStream.getPosition() + 1;
1644     throw e;
1645   }
1646   (
1647    (  <STAR>      {operator = OperatorIds.MULTIPLY;}
1648     | <SLASH>     {operator = OperatorIds.DIVIDE;}
1649     | <REMAINDER> {operator = OperatorIds.REMAINDER;})
1650     expr2 = UnaryExpression()
1651     {expr = new BinaryExpression(expr,expr2,operator);}
1652   )*
1653   {return expr;}
1654 }
1655
1656 /**
1657  * An unary expression starting with @, & or nothing
1658  */
1659 Expression UnaryExpression() :
1660 {
1661   final Expression expr;
1662 }
1663 {
1664  /* <BIT_AND> expr = UnaryExpressionNoPrefix()             //why did I had that ?
1665   {return new PrefixedUnaryExpression(expr,OperatorIds.AND,pos);}
1666 |      */
1667   expr = AtNotUnaryExpression() {return expr;}
1668 }
1669
1670 /**
1671  * An expression prefixed (or not) by one or more @ and !.
1672  * @return the expression
1673  */
1674 Expression AtNotUnaryExpression() :
1675 {
1676   final Expression expr;
1677   final Token token;
1678 }
1679 {
1680   token = <AT>
1681   expr = AtNotUnaryExpression()
1682   {return new PrefixedUnaryExpression(expr,OperatorIds.AT,token.sourceStart);}
1683 |
1684   token = <BANG>
1685   expr = AtNotUnaryExpression()
1686   {return new PrefixedUnaryExpression(expr,OperatorIds.NOT,token.sourceStart);}
1687 |
1688   expr = UnaryExpressionNoPrefix()
1689   {return expr;}
1690 }
1691
1692 Expression UnaryExpressionNoPrefix() :
1693 {
1694   final Expression expr;
1695   final Token token;
1696 }
1697 {
1698   token = <PLUS> expr = AtNotUnaryExpression()   {return new PrefixedUnaryExpression(expr,
1699                                                                                      OperatorIds.PLUS,
1700                                                                                      token.sourceStart);}
1701 |
1702   token = <MINUS> expr = AtNotUnaryExpression()  {return new PrefixedUnaryExpression(expr,
1703                                                                                      OperatorIds.MINUS,
1704                                                                                      token.sourceStart);}
1705 |
1706   expr = PreIncDecExpression()
1707   {return expr;}
1708 |
1709   expr = UnaryExpressionNotPlusMinus()
1710   {return expr;}
1711 }
1712
1713
1714 Expression PreIncDecExpression() :
1715 {
1716 final Expression expr;
1717 final int operator;
1718 final Token token;
1719 }
1720 {
1721   (
1722       token = <PLUS_PLUS>   {operator = OperatorIds.PLUS_PLUS;}
1723     |
1724       token = <MINUS_MINUS> {operator = OperatorIds.MINUS_MINUS;}
1725   )
1726   expr = PrimaryExpression()
1727   {return new PrefixedUnaryExpression(expr,operator,token.sourceStart);}
1728 }
1729
1730 Expression UnaryExpressionNotPlusMinus() :
1731 {
1732   final Expression expr;
1733 }
1734 {
1735   LOOKAHEAD( <LPAREN> (Type() | <ARRAY>) <RPAREN> )
1736   expr = CastExpression()         {return expr;}
1737 | expr = PostfixExpression()      {return expr;}
1738 | expr = Literal()                {return expr;}
1739 | <LPAREN> expr = Expression()
1740   try {
1741     <RPAREN>
1742   } catch (ParseException e) {
1743     errorMessage = "')' expected";
1744     errorLevel   = ERROR;
1745     errorStart   = SimpleCharStream.getPosition() - e.currentToken.next.image.length() + 1;
1746     errorEnd     = SimpleCharStream.getPosition() + 1;
1747     throw e;
1748   }
1749   {return expr;}
1750 }
1751
1752 CastExpression CastExpression() :
1753 {
1754 final ConstantIdentifier type;
1755 final Expression expr;
1756 final Token token,token1;
1757 }
1758 {
1759   token1 = <LPAREN>
1760   (
1761       type = Type()
1762     |
1763       token = <ARRAY> {type = new ConstantIdentifier(token);}
1764   )
1765   <RPAREN> expr = UnaryExpression()
1766   {return new CastExpression(type,expr,token1.sourceStart,expr.sourceEnd);}
1767 }
1768
1769 Expression PostfixExpression() :
1770 {
1771   final Expression expr;
1772   int operator = -1;
1773   Token token = null;
1774 }
1775 {
1776   expr = PrimaryExpression()
1777   [
1778       token = <PLUS_PLUS>   {operator = OperatorIds.PLUS_PLUS;}
1779     |
1780       token = <MINUS_MINUS> {operator = OperatorIds.MINUS_MINUS;}
1781   ]
1782   {
1783     if (operator == -1) {
1784       return expr;
1785     }
1786     return new PostfixedUnaryExpression(expr,operator,token.sourceEnd);
1787   }
1788 }
1789
1790 Expression PrimaryExpression() :
1791 {
1792   Expression expr;
1793   Token token = null;
1794 }
1795 {
1796   [token = <BIT_AND>] expr = refPrimaryExpression(token)
1797   {return expr;}
1798 |
1799   expr = ArrayDeclarator()
1800   {return expr;}
1801 }
1802
1803 Expression refPrimaryExpression(final Token reference) :
1804 {
1805   Expression expr;
1806   Expression expr2 = null;
1807   final Token identifier;
1808 }
1809 {
1810   identifier = <IDENTIFIER>
1811   {
1812     expr = new ConstantIdentifier(identifier);
1813   }
1814   (
1815     <STATICCLASSACCESS> expr2 = ClassIdentifier()
1816     {expr = new ClassAccess(expr,
1817                             expr2,
1818                             ClassAccess.STATIC);}
1819   )*
1820   [ expr2 = Arguments(expr) ]
1821   {
1822     if (expr2 == null) {
1823       if (reference != null) {
1824         ParseException e = generateParseException();
1825         errorMessage = "you cannot use a constant by reference";
1826         errorLevel   = ERROR;
1827         errorStart   = reference.sourceStart;
1828         errorEnd     = reference.sourceEnd;
1829         processParseExceptionDebug(e);
1830       }
1831       return expr;
1832     }
1833     return expr2;
1834   }
1835 |
1836   expr = VariableDeclaratorId()  //todo use the reference parameter ...
1837   [ expr = Arguments(expr) ]
1838   {return expr;}
1839 |
1840   token = <NEW>
1841   expr = ClassIdentifier()
1842   {
1843     int start;
1844     if (reference == null) {
1845       start = token.sourceStart;
1846     } else {
1847       start = reference.sourceStart;
1848     }
1849     expr = new ClassInstantiation(expr,
1850                                   reference != null,
1851                                   start);
1852   }
1853   [ expr = Arguments(expr) ]
1854   {return expr;}
1855 }
1856
1857 /**
1858  * An array declarator.
1859  * array(vars)
1860  * @return an array
1861  */
1862 ArrayInitializer ArrayDeclarator() :
1863 {
1864   final ArrayVariableDeclaration[] vars;
1865   final Token token;
1866 }
1867 {
1868   token = <ARRAY> vars = ArrayInitializer()
1869   {return new ArrayInitializer(vars,token.sourceStart,SimpleCharStream.getPosition());}
1870 }
1871
1872 Expression ClassIdentifier():
1873 {
1874   final Expression expr;
1875   final Token token;
1876 }
1877 {
1878   token = <IDENTIFIER>          {return new ConstantIdentifier(token);}
1879 | expr = Type()                 {return expr;}
1880 | expr = VariableDeclaratorId() {return expr;}
1881 }
1882
1883 /**
1884  * Used by Variabledeclaratorid and primarysuffix
1885  */
1886 AbstractVariable VariableSuffix(final AbstractVariable prefix) :
1887 {
1888   Expression expression = null;
1889   final Token classAccessToken;
1890 }
1891 {
1892   classAccessToken = <CLASSACCESS>
1893   try {
1894     ( expression = VariableName() | expression = Variable() )
1895   } catch (ParseException e) {
1896     errorMessage = "unexpected token : '"+ e.currentToken.next.image +"', function call or field access expected";
1897     errorLevel   = ERROR;
1898     errorStart = classAccessToken.sourceEnd +1;
1899     errorEnd   = classAccessToken.sourceEnd +1;
1900     processParseExceptionDebug(e);
1901   }
1902   {return new ClassAccess(prefix,
1903                           expression,
1904                           ClassAccess.NORMAL);}
1905 |
1906   <LBRACKET> [ expression = Expression() | expression = Type() ]  //Not good
1907   try {
1908     <RBRACKET>
1909   } catch (ParseException e) {
1910     errorMessage = "']' expected";
1911     errorLevel   = ERROR;
1912     errorStart = SimpleCharStream.getPosition() - e.currentToken.next.image.length() + 1;
1913     errorEnd   = SimpleCharStream.getPosition() + 1;
1914     throw e;
1915   }
1916   {return new ArrayDeclarator(prefix,expression,SimpleCharStream.getPosition());}
1917 }
1918
1919 Literal Literal() :
1920 {
1921   final Token token;
1922 }
1923 {
1924   token = <INTEGER_LITERAL>        {return new NumberLiteral(token);}
1925 | token = <FLOATING_POINT_LITERAL> {return new NumberLiteral(token);}
1926 | token = <STRING_LITERAL>         {return new StringLiteral(token);}
1927 | token = <TRUE>                   {return new TrueLiteral(token);}
1928 | token = <FALSE>                  {return new FalseLiteral(token);}
1929 | token = <NULL>                   {return new NullLiteral(token);}
1930 }
1931
1932 FunctionCall Arguments(final Expression func) :
1933 {
1934 Expression[] args = null;
1935 final Token token;
1936 }
1937 {
1938   <LPAREN> [ args = ArgumentList() ]
1939   try {
1940     token = <RPAREN>
1941   } catch (ParseException e) {
1942     errorMessage = "unexpected token : '"+ e.currentToken.next.image +"', ')' expected to close the argument list";
1943     errorLevel   = ERROR;
1944     errorStart = SimpleCharStream.getPosition() - e.currentToken.next.image.length() + 1;
1945     errorEnd   = SimpleCharStream.getPosition() + 1;
1946     throw e;
1947   }
1948   {return new FunctionCall(func,args,token.sourceEnd);}
1949 }
1950
1951 /**
1952  * An argument list is a list of arguments separated by comma :
1953  * argumentDeclaration() (, argumentDeclaration)*
1954  * @return an array of arguments
1955  */
1956 Expression[] ArgumentList() :
1957 {
1958 Expression arg;
1959 final ArrayList list = new ArrayList();
1960 }
1961 {
1962   arg = Expression()
1963   {list.add(arg);}
1964   ( <COMMA>
1965       try {
1966         arg = Expression()
1967         {list.add(arg);}
1968       } catch (ParseException e) {
1969         errorMessage = "unexpected token : '"+ e.currentToken.next.image +"'. An expression expected after a comma in argument list";
1970         errorLevel   = ERROR;
1971         errorStart   = SimpleCharStream.getPosition() - e.currentToken.next.image.length() + 1;
1972         errorEnd     = SimpleCharStream.getPosition() + 1;
1973         throw e;
1974       }
1975    )*
1976    {
1977    final Expression[] arguments = new Expression[list.size()];
1978    list.toArray(arguments);
1979    return arguments;}
1980 }
1981
1982 /**
1983  * A Statement without break.
1984  * @return a statement
1985  */
1986 Statement StatementNoBreak() :
1987 {
1988   final Statement statement;
1989   Token token = null;
1990 }
1991 {
1992   LOOKAHEAD(2)
1993   statement = expressionStatement()     {return statement;}
1994 | LOOKAHEAD(1)
1995   statement = LabeledStatement()        {return statement;}
1996 | statement = Block()                   {return statement;}
1997 | statement = EmptyStatement()          {return statement;}
1998 | statement = SwitchStatement()         {return statement;}
1999 | statement = IfStatement()             {return statement;}
2000 | statement = WhileStatement()          {return statement;}
2001 | statement = DoStatement()             {return statement;}
2002 | statement = ForStatement()            {return statement;}
2003 | statement = ForeachStatement()        {return statement;}
2004 | statement = ContinueStatement()       {return statement;}
2005 | statement = ReturnStatement()         {return statement;}
2006 | statement = EchoStatement()           {return statement;}
2007 | [token=<AT>] statement = IncludeStatement()
2008   {if (token != null) {
2009     ((InclusionStatement)statement).silent = true;
2010     statement.sourceStart = token.sourceStart;
2011   }
2012   return statement;}
2013 | statement = StaticStatement()         {return statement;}
2014 | statement = GlobalStatement()         {return statement;}
2015 | statement = defineStatement()         {currentSegment.add((Outlineable)statement);return statement;}
2016 }
2017
2018 /**
2019  * A statement expression.
2020  * expression ;
2021  * @return an expression
2022  */
2023 Statement expressionStatement() :
2024 {
2025   final Statement statement;
2026   final Token token;
2027 }
2028 {
2029   statement = Expression()
2030   try {
2031     token = <SEMICOLON>
2032     {statement.sourceEnd = token.sourceEnd;}
2033   } catch (ParseException e) {
2034     if (e.currentToken.next.kind != PHPParserConstants.PHPEND) {
2035       errorMessage = "unexpected token : '"+ e.currentToken.next.image +"'. A ';' was expected";
2036       errorLevel   = ERROR;
2037       errorStart = SimpleCharStream.getPosition() - e.currentToken.next.image.length() + 1;
2038       errorEnd   = SimpleCharStream.getPosition() + 1;
2039       throw e;
2040     }
2041   }
2042   {return statement;}
2043 }
2044
2045 Define defineStatement() :
2046 {
2047   final int start = SimpleCharStream.getPosition();
2048   Expression defineName,defineValue;
2049 }
2050 {
2051   <DEFINE>
2052   try {
2053     <LPAREN>
2054   } catch (ParseException e) {
2055     errorMessage = "unexpected token : '"+ e.currentToken.next.image +"', '(' expected";
2056     errorLevel   = ERROR;
2057     errorStart   = SimpleCharStream.getPosition() - e.currentToken.next.image.length() + 1;
2058     errorEnd     = SimpleCharStream.getPosition() + 1;
2059     processParseExceptionDebug(e);
2060   }
2061   try {
2062     defineName = Expression()
2063   } catch (ParseException e) {
2064     errorMessage = "unexpected token : '"+ e.currentToken.next.image +"', expression expected";
2065     errorLevel   = ERROR;
2066     errorStart   = SimpleCharStream.getPosition() - e.currentToken.next.image.length() + 1;
2067     errorEnd     = SimpleCharStream.getPosition() + 1;
2068     throw e;
2069   }
2070   try {
2071     <COMMA>
2072   } catch (ParseException e) {
2073     errorMessage = "unexpected token : '"+ e.currentToken.next.image +"', ',' expected";
2074     errorLevel   = ERROR;
2075     errorStart   = SimpleCharStream.getPosition() - e.currentToken.next.image.length() + 1;
2076     errorEnd     = SimpleCharStream.getPosition() + 1;
2077     processParseExceptionDebug(e);
2078   }
2079   try {
2080     defineValue = Expression()
2081   } catch (ParseException e) {
2082     errorMessage = "unexpected token : '"+ e.currentToken.next.image +"', expression expected";
2083     errorLevel   = ERROR;
2084     errorStart   = SimpleCharStream.getPosition() - e.currentToken.next.image.length() + 1;
2085     errorEnd     = SimpleCharStream.getPosition() + 1;
2086     throw e;
2087   }
2088   try {
2089     <RPAREN>
2090   } catch (ParseException e) {
2091     errorMessage = "unexpected token : '"+ e.currentToken.next.image +"', ')' expected";
2092     errorLevel   = ERROR;
2093     errorStart   = SimpleCharStream.getPosition() - e.currentToken.next.image.length() + 1;
2094     errorEnd     = SimpleCharStream.getPosition() + 1;
2095     processParseExceptionDebug(e);
2096   }
2097   {return new Define(currentSegment,
2098                      defineName,
2099                      defineValue,
2100                      start,
2101                      SimpleCharStream.getPosition());}
2102 }
2103
2104 /**
2105  * A Normal statement.
2106  */
2107 Statement Statement() :
2108 {
2109   final Statement statement;
2110 }
2111 {
2112   statement = StatementNoBreak() {return statement;}
2113 | statement = BreakStatement()   {return statement;}
2114 }
2115
2116 /**
2117  * An html block inside a php syntax.
2118  */
2119 HTMLBlock htmlBlock() :
2120 {
2121   final int startIndex = nodePtr;
2122   final AstNode[] blockNodes;
2123   final int nbNodes;
2124 }
2125 {
2126   <PHPEND> (phpEchoBlock())*
2127   try {
2128     (<PHPSTARTLONG> | <PHPSTARTSHORT>)
2129   } catch (ParseException e) {
2130     errorMessage = "unexpected end of file , '<?php' expected";
2131     errorLevel   = ERROR;
2132     errorStart   = SimpleCharStream.getPosition();
2133     errorEnd     = SimpleCharStream.getPosition();
2134     throw e;
2135   }
2136   {
2137   nbNodes    = nodePtr - startIndex;
2138   blockNodes = new AstNode[nbNodes];
2139   System.arraycopy(nodes,startIndex,blockNodes,0,nbNodes);
2140   nodePtr = startIndex;
2141   return new HTMLBlock(blockNodes);}
2142 }
2143
2144 /**
2145  * An include statement. It's "include" an expression;
2146  */
2147 InclusionStatement IncludeStatement() :
2148 {
2149   final Expression expr;
2150   final int keyword;
2151   final InclusionStatement inclusionStatement;
2152   final Token token, token2;
2153 }
2154 {
2155       (  token = <REQUIRE>      {keyword = InclusionStatement.REQUIRE;}
2156        | token = <REQUIRE_ONCE> {keyword = InclusionStatement.REQUIRE_ONCE;}
2157        | token = <INCLUDE>      {keyword = InclusionStatement.INCLUDE;}
2158        | token = <INCLUDE_ONCE> {keyword = InclusionStatement.INCLUDE_ONCE;})
2159   try {
2160     expr = Expression()
2161   } catch (ParseException e) {
2162     if (errorMessage != null) {
2163       throw e;
2164     }
2165     errorMessage = "unexpected token '"+ e.currentToken.next.image+"', expression expected";
2166     errorLevel   = ERROR;
2167     errorStart   = SimpleCharStream.getPosition() - e.currentToken.next.image.length() + 1;
2168     errorEnd     = SimpleCharStream.getPosition() + 1;
2169     throw e;
2170   }
2171   {inclusionStatement = new InclusionStatement(currentSegment,
2172                                                keyword,
2173                                                expr,
2174                                                token.sourceStart);
2175    currentSegment.add(inclusionStatement);
2176   }
2177   try {
2178     token2 = <SEMICOLON>
2179   } catch (ParseException e) {
2180     errorMessage = "unexpected token : '"+ e.currentToken.next.image +"'. A ';' was expected";
2181     errorLevel   = ERROR;
2182     errorStart   = SimpleCharStream.getPosition() - e.currentToken.next.image.length() + 1;
2183     errorEnd     = SimpleCharStream.getPosition() + 1;
2184     throw e;
2185   }
2186   {inclusionStatement.sourceEnd = token2.sourceEnd;
2187   return inclusionStatement;}
2188 }
2189
2190 PrintExpression PrintExpression() :
2191 {
2192   final Expression expr;
2193   final int pos = SimpleCharStream.getPosition();
2194 }
2195 {
2196   <PRINT> expr = Expression() {return new PrintExpression(expr,pos,SimpleCharStream.getPosition());}
2197 }
2198
2199 ListExpression ListExpression() :
2200 {
2201   Expression expr = null;
2202   final Expression expression;
2203   final ArrayList list = new ArrayList();
2204   final int pos = SimpleCharStream.getPosition();
2205   final Token listToken;
2206 }
2207 {
2208   listToken = <LIST>
2209   try {
2210     <LPAREN>
2211   } catch (ParseException e) {
2212     errorMessage = "unexpected token : '"+ e.currentToken.next.image +"', '(' expected";
2213     errorLevel   = ERROR;
2214     errorStart   = listToken.sourceEnd+1;
2215     errorEnd     = listToken.sourceEnd+1;
2216     processParseExceptionDebug(e);
2217   }
2218   [
2219     expr = VariableDeclaratorId()
2220     {list.add(expr);}
2221   ]
2222   {if (expr == null) list.add(null);}
2223   (
2224     try {
2225       <COMMA>
2226     } catch (ParseException e) {
2227       errorMessage = "unexpected token : '"+ e.currentToken.next.image +"', ',' expected";
2228       errorLevel   = ERROR;
2229       errorStart   = SimpleCharStream.getPosition() - e.currentToken.next.image.length() + 1;
2230       errorEnd     = SimpleCharStream.getPosition() + 1;
2231       throw e;
2232     }
2233     [expr = VariableDeclaratorId() {list.add(expr);}]
2234   )*
2235   try {
2236     <RPAREN>
2237   } catch (ParseException e) {
2238     errorMessage = "unexpected token : '"+ e.currentToken.next.image +"', ')' expected";
2239     errorLevel   = ERROR;
2240     errorStart = SimpleCharStream.getPosition() - e.currentToken.next.image.length() + 1;
2241     errorEnd   = SimpleCharStream.getPosition() + 1;
2242     throw e;
2243   }
2244   [ <ASSIGN> expression = Expression()
2245     {
2246     final AbstractVariable[] vars = new AbstractVariable[list.size()];
2247     list.toArray(vars);
2248     return new ListExpression(vars,
2249                               expression,
2250                               pos,
2251                               SimpleCharStream.getPosition());}
2252   ]
2253   {
2254     final Variable[] vars = new Variable[list.size()];
2255     list.toArray(vars);
2256     return new ListExpression(vars,pos,SimpleCharStream.getPosition());}
2257 }
2258
2259 /**
2260  * An echo statement.
2261  * echo anyexpression (, otherexpression)*
2262  */
2263 EchoStatement EchoStatement() :
2264 {
2265   final ArrayList expressions = new ArrayList();
2266   Expression expr;
2267   Token token;
2268   Token token2 = null;
2269 }
2270 {
2271   token = <ECHO> expr = Expression()
2272   {expressions.add(expr);}
2273   (
2274     <COMMA> expr = Expression()
2275     {expressions.add(expr);}
2276   )*
2277   try {
2278     token2 = <SEMICOLON>
2279   } catch (ParseException e) {
2280     if (e.currentToken.next.kind != 4) {
2281       errorMessage = "';' expected after 'echo' statement";
2282       errorLevel   = ERROR;
2283       errorStart   = e.currentToken.sourceEnd;
2284       errorEnd     = e.currentToken.sourceEnd;
2285       processParseExceptionDebug(e);
2286     }
2287   }
2288   {
2289    final Expression[] exprs = new Expression[expressions.size()];
2290    expressions.toArray(exprs);
2291    if (token2 == null) {
2292      return new EchoStatement(exprs,token.sourceStart, exprs[exprs.length-1].sourceEnd);
2293    }
2294    return new EchoStatement(exprs,token.sourceStart, token2.sourceEnd);
2295    }
2296 }
2297
2298 GlobalStatement GlobalStatement() :
2299 {
2300    Variable expr;
2301    final ArrayList vars = new ArrayList();
2302    final GlobalStatement global;
2303    final Token token, token2;
2304 }
2305 {
2306   token = <GLOBAL>
2307     expr = Variable()
2308     {vars.add(expr);}
2309   (<COMMA>
2310     expr = Variable()
2311     {vars.add(expr);}
2312   )*
2313   try {
2314     token2 = <SEMICOLON>
2315     {
2316     final Variable[] variables = new Variable[vars.size()];
2317     vars.toArray(variables);
2318     global = new GlobalStatement(currentSegment,
2319                                  variables,
2320                                  token.sourceStart,
2321                                  token2.sourceEnd);
2322     currentSegment.add(global);
2323     return global;}
2324   } catch (ParseException e) {
2325     errorMessage = "unexpected token : '"+ e.currentToken.next.image +"'. a ';' was expected";
2326     errorLevel   = ERROR;
2327     errorStart = SimpleCharStream.getPosition() - e.currentToken.next.image.length() + 1;
2328     errorEnd   = SimpleCharStream.getPosition() + 1;
2329     throw e;
2330   }
2331 }
2332
2333 StaticStatement StaticStatement() :
2334 {
2335   final ArrayList vars = new ArrayList();
2336   VariableDeclaration expr;
2337   final Token token, token2;
2338 }
2339 {
2340   token = <STATIC> expr = VariableDeclarator() {vars.add(expr);}
2341   (
2342     <COMMA> expr = VariableDeclarator() {vars.add(expr);}
2343   )*
2344   try {
2345     token2 = <SEMICOLON>
2346     {
2347     final VariableDeclaration[] variables = new VariableDeclaration[vars.size()];
2348     vars.toArray(variables);
2349     return new StaticStatement(variables,
2350                                token.sourceStart,
2351                                token2.sourceEnd);}
2352   } catch (ParseException e) {
2353     errorMessage = "unexpected token : '"+ e.currentToken.next.image +"'. a ';' was expected";
2354     errorLevel   = ERROR;
2355     errorStart = SimpleCharStream.getPosition() - e.currentToken.next.image.length() + 1;
2356     errorEnd   = SimpleCharStream.getPosition() + 1;
2357     throw e;
2358   }
2359 }
2360
2361 LabeledStatement LabeledStatement() :
2362 {
2363   final Token label;
2364   final Statement statement;
2365 }
2366 {
2367   label = <IDENTIFIER> <COLON> statement = Statement()
2368   {return new LabeledStatement(label.image,statement,label.sourceStart,statement.sourceEnd);}
2369 }
2370
2371 /**
2372  * A Block is
2373  * {
2374  * statements
2375  * }.
2376  * @return a block
2377  */
2378 Block Block() :
2379 {
2380   final ArrayList list = new ArrayList();
2381   Statement statement;
2382   final Token token, token2;
2383 }
2384 {
2385   try {
2386     token = <LBRACE>
2387   } catch (ParseException e) {
2388     errorMessage = "'{' expected";
2389     errorLevel   = ERROR;
2390     errorStart = SimpleCharStream.getPosition() - e.currentToken.next.image.length() + 1;
2391     errorEnd   = SimpleCharStream.getPosition() + 1;
2392     throw e;
2393   }
2394   ( statement = BlockStatement() {list.add(statement);}
2395   | statement = htmlBlock()      {list.add(statement);})*
2396   try {
2397     token2 = <RBRACE>
2398   } catch (ParseException e) {
2399     errorMessage = "unexpected token : '"+ e.currentToken.image +"', '}' expected";
2400     errorLevel   = ERROR;
2401     errorStart = SimpleCharStream.getPosition() - e.currentToken.next.image.length() + 1;
2402     errorEnd   = SimpleCharStream.getPosition() + 1;
2403     throw e;
2404   }
2405   {
2406   final Statement[] statements = new Statement[list.size()];
2407   list.toArray(statements);
2408   return new Block(statements,token.sourceStart,token2.sourceEnd);}
2409 }
2410
2411 Statement BlockStatement() :
2412 {
2413   final Statement statement;
2414 }
2415 {
2416   try {
2417     statement = Statement()         {if (phpDocument == currentSegment) pushOnAstNodes(statement);
2418                                      return statement;}
2419   } catch (ParseException e) {
2420     errorMessage = "unexpected token : '"+ e.currentToken.image +"', a statement was expected";
2421     errorLevel   = ERROR;
2422     errorStart = e.currentToken.sourceStart;
2423     errorEnd   = e.currentToken.sourceEnd;
2424     throw e;
2425   }
2426 | statement = ClassDeclaration()  {return statement;}
2427 | statement = MethodDeclaration() {if (phpDocument == currentSegment) pushOnAstNodes(statement);
2428                                    currentSegment.add((MethodDeclaration) statement);
2429                                    ((MethodDeclaration) statement).analyzeCode();
2430                                    return statement;}
2431 }
2432
2433 /**
2434  * A Block statement that will not contain any 'break'
2435  */
2436 Statement BlockStatementNoBreak() :
2437 {
2438   final Statement statement;
2439 }
2440 {
2441   statement = StatementNoBreak()  {return statement;}
2442 | statement = ClassDeclaration()  {return statement;}
2443 | statement = MethodDeclaration() {currentSegment.add((MethodDeclaration) statement);
2444                                    ((MethodDeclaration) statement).analyzeCode();
2445                                    return statement;}
2446 }
2447
2448 /**
2449  * used only by ForInit()
2450  */
2451 Expression[] LocalVariableDeclaration() :
2452 {
2453   final ArrayList list = new ArrayList();
2454   Expression var;
2455 }
2456 {
2457   var = Expression()
2458   {list.add(var);}
2459   ( <COMMA> var = Expression() {list.add(var);})*
2460   {
2461     final Expression[] vars = new Expression[list.size()];
2462     list.toArray(vars);
2463     return vars;
2464   }
2465 }
2466
2467 /**
2468  * used only by LocalVariableDeclaration().
2469  */
2470 VariableDeclaration LocalVariableDeclarator() :
2471 {
2472   final Variable varName;
2473   Expression initializer = null;
2474 }
2475 {
2476   varName = Variable() [ <ASSIGN> initializer = Expression() ]
2477   {
2478    if (initializer == null) {
2479     return new VariableDeclaration(currentSegment,
2480                                    varName,
2481                                    varName.sourceStart,
2482                                    varName.sourceEnd);
2483    }
2484     return new VariableDeclaration(currentSegment,
2485                                    varName,
2486                                    initializer,
2487                                    VariableDeclaration.EQUAL,
2488                                    varName.sourceStart);
2489   }
2490 }
2491
2492 EmptyStatement EmptyStatement() :
2493 {
2494   final Token token;
2495 }
2496 {
2497   token = <SEMICOLON>
2498   {return new EmptyStatement(token.sourceStart,token.sourceEnd);}
2499 }
2500
2501 /**
2502  * used only by StatementExpressionList() which is used only by ForInit() and ForStatement()
2503  */
2504 Expression StatementExpression() :
2505 {
2506   final Expression expr;
2507 }
2508 {
2509   expr = PreIncDecExpression() {return expr;}
2510 |
2511   expr = PrimaryExpression()
2512   [ <PLUS_PLUS> {return new PostfixedUnaryExpression(expr,
2513                                                      OperatorIds.PLUS_PLUS,
2514                                                      SimpleCharStream.getPosition());}
2515   | <MINUS_MINUS> {return new PostfixedUnaryExpression(expr,
2516                                                        OperatorIds.MINUS_MINUS,
2517                                                        SimpleCharStream.getPosition());}
2518   ]
2519   {return expr;}
2520 }
2521
2522 SwitchStatement SwitchStatement() :
2523 {
2524   final Expression variable;
2525   final AbstractCase[] cases;
2526   final int pos = SimpleCharStream.getPosition();
2527   final Token switchToken;
2528 }
2529 {
2530   switchToken = <SWITCH>
2531   try {
2532     <LPAREN>
2533   } catch (ParseException e) {
2534     errorMessage = "'(' expected after 'switch'";
2535     errorLevel   = ERROR;
2536     errorStart = SimpleCharStream.getPosition() - e.currentToken.next.image.length() + 1;
2537     errorEnd   = SimpleCharStream.getPosition() + 1;
2538     throw e;
2539   }
2540   try {
2541     variable = Expression()
2542   } catch (ParseException e) {
2543     if (errorMessage != null) {
2544       throw e;
2545     }
2546     errorMessage = "expression expected";
2547     errorLevel   = ERROR;
2548     errorStart = SimpleCharStream.getPosition() - e.currentToken.next.image.length() + 1;
2549     errorEnd   = SimpleCharStream.getPosition() + 1;
2550     throw e;
2551   }
2552   try {
2553     <RPAREN>
2554   } catch (ParseException e) {
2555     errorMessage = "')' expected";
2556     errorLevel   = ERROR;
2557     errorStart = SimpleCharStream.getPosition() - e.currentToken.next.image.length() + 1;
2558     errorEnd   = SimpleCharStream.getPosition() + 1;
2559     throw e;
2560   }
2561   (cases = switchStatementBrace() | cases = switchStatementColon(switchToken.sourceStart, switchToken.sourceEnd))
2562   {return new SwitchStatement(variable,cases,switchToken.sourceStart,SimpleCharStream.getPosition());}
2563 }
2564
2565 AbstractCase[] switchStatementBrace() :
2566 {
2567   AbstractCase cas;
2568   final ArrayList cases = new ArrayList();
2569 }
2570 {
2571   <LBRACE>
2572  ( cas = switchLabel0() {cases.add(cas);})*
2573   try {
2574     <RBRACE>
2575     {
2576     final AbstractCase[] abcase = new AbstractCase[cases.size()];
2577     cases.toArray(abcase);
2578     return abcase;}
2579   } catch (ParseException e) {
2580     errorMessage = "'}' expected";
2581     errorLevel   = ERROR;
2582     errorStart = SimpleCharStream.getPosition() - e.currentToken.next.image.length() + 1;
2583     errorEnd   = SimpleCharStream.getPosition() + 1;
2584     throw e;
2585   }
2586 }
2587 /**
2588  * A Switch statement with : ... endswitch;
2589  * @param start the begin offset of the switch
2590  * @param end the end offset of the switch
2591  */
2592 AbstractCase[] switchStatementColon(final int start, final int end) :
2593 {
2594   AbstractCase cas;
2595   final ArrayList cases = new ArrayList();
2596 }
2597 {
2598   <COLON>
2599   {try {
2600   setMarker(fileToParse,
2601             "Ugly syntax detected, you should switch () {...} instead of switch (): ... enswitch;",
2602             start,
2603             end,
2604             INFO,
2605             "Line " + token.beginLine);
2606   } catch (CoreException e) {
2607     PHPeclipsePlugin.log(e);
2608   }}
2609   ( cas = switchLabel0() {cases.add(cas);})*
2610   try {
2611     <ENDSWITCH>
2612   } catch (ParseException e) {
2613     errorMessage = "'endswitch' expected";
2614     errorLevel   = ERROR;
2615     errorStart = SimpleCharStream.getPosition() - e.currentToken.next.image.length() + 1;
2616     errorEnd   = SimpleCharStream.getPosition() + 1;
2617     throw e;
2618   }
2619   try {
2620     <SEMICOLON>
2621     {
2622     final AbstractCase[] abcase = new AbstractCase[cases.size()];
2623     cases.toArray(abcase);
2624     return abcase;}
2625   } catch (ParseException e) {
2626     errorMessage = "';' expected after 'endswitch' keyword";
2627     errorLevel   = ERROR;
2628     errorStart = SimpleCharStream.getPosition() - e.currentToken.next.image.length() + 1;
2629     errorEnd   = SimpleCharStream.getPosition() + 1;
2630     throw e;
2631   }
2632 }
2633
2634 AbstractCase switchLabel0() :
2635 {
2636   final Expression expr;
2637   Statement statement;
2638   final ArrayList stmts = new ArrayList();
2639   final int pos = SimpleCharStream.getPosition();
2640 }
2641 {
2642   expr = SwitchLabel()
2643   ( statement = BlockStatementNoBreak() {stmts.add(statement);}
2644   | statement = htmlBlock()             {stmts.add(statement);})*
2645   [ statement = BreakStatement()        {stmts.add(statement);}]
2646   {
2647   final Statement[] stmtsArray = new Statement[stmts.size()];
2648   stmts.toArray(stmtsArray);
2649   if (expr == null) {//it's a default
2650     return new DefaultCase(stmtsArray,pos,SimpleCharStream.getPosition());
2651   }
2652   return new Case(expr,stmtsArray,pos,SimpleCharStream.getPosition());}
2653 }
2654
2655 /**
2656  * A SwitchLabel.
2657  * case Expression() :
2658  * default :
2659  * @return the if it was a case and null if not
2660  */
2661 Expression SwitchLabel() :
2662 {
2663   final Expression expr;
2664 }
2665 {
2666   token = <CASE>
2667   try {
2668     expr = Expression()
2669   } catch (ParseException e) {
2670     if (errorMessage != null) throw e;
2671     errorMessage = "expression expected after 'case' keyword";
2672     errorLevel   = ERROR;
2673     errorStart = token.sourceEnd +1;
2674     errorEnd   = token.sourceEnd +1;
2675     throw e;
2676   }
2677   try {
2678     token = <COLON>
2679     {return expr;}
2680   } catch (ParseException e) {
2681     errorMessage = "':' expected after case expression";
2682     errorLevel   = ERROR;
2683     errorStart = expr.sourceEnd+1;
2684     errorEnd   = expr.sourceEnd+1;
2685     processParseExceptionDebug(e);
2686   }
2687 |
2688   token = <_DEFAULT>
2689   try {
2690     <COLON>
2691     {return null;}
2692   } catch (ParseException e) {
2693     errorMessage = "':' expected after 'default' keyword";
2694     errorLevel   = ERROR;
2695     errorStart = token.sourceEnd+1;
2696     errorEnd   = token.sourceEnd+1;
2697     processParseExceptionDebug(e);
2698   }
2699 }
2700
2701 Break BreakStatement() :
2702 {
2703   Expression expression = null;
2704   final Token token, token2;
2705 }
2706 {
2707   token = <BREAK> [ expression = Expression() ]
2708   try {
2709     token2 = <SEMICOLON>
2710   } catch (ParseException e) {
2711     errorMessage = "';' expected after 'break' keyword";
2712     errorLevel   = ERROR;
2713     errorStart = SimpleCharStream.getPosition() - e.currentToken.next.image.length() + 1;
2714     errorEnd   = SimpleCharStream.getPosition() + 1;
2715     throw e;
2716   }
2717   {return new Break(expression, token.sourceStart, token2.sourceEnd);}
2718 }
2719
2720 IfStatement IfStatement() :
2721 {
2722   final Expression condition;
2723   final IfStatement ifStatement;
2724   Token token;
2725 }
2726 {
2727   token = <IF> condition = Condition("if")
2728   ifStatement = IfStatement0(condition,token.sourceStart,token.sourceEnd)
2729   {return ifStatement;}
2730 }
2731
2732
2733 Expression Condition(final String keyword) :
2734 {
2735   final Expression condition;
2736 }
2737 {
2738   try {
2739     <LPAREN>
2740   } catch (ParseException e) {
2741     errorMessage = "'(' expected after " + keyword + " keyword";
2742     errorLevel   = ERROR;
2743     errorStart = SimpleCharStream.getPosition() - e.currentToken.next.image.length();
2744     errorEnd   = errorStart +1;
2745     processParseExceptionDebug(e);
2746   }
2747   condition = Expression()
2748   try {
2749      <RPAREN>
2750   } catch (ParseException e) {
2751     errorMessage = "')' expected after " + keyword + " keyword";
2752     errorLevel   = ERROR;
2753     errorStart = SimpleCharStream.getPosition() - e.currentToken.next.image.length() + 1;
2754     errorEnd   = SimpleCharStream.getPosition() + 1;
2755     processParseExceptionDebug(e);
2756   }
2757   {return condition;}
2758 }
2759
2760 IfStatement IfStatement0(final Expression condition, final int start,final int end) :
2761 {
2762   Statement statement;
2763   final Statement stmt;
2764   final Statement[] statementsArray;
2765   ElseIf elseifStatement;
2766   Else elseStatement = null;
2767   final ArrayList stmts;
2768   final ArrayList elseIfList = new ArrayList();
2769   final ElseIf[] elseIfs;
2770   int pos = SimpleCharStream.getPosition();
2771   final int endStatements;
2772 }
2773 {
2774   <COLON>
2775   {stmts = new ArrayList();}
2776   (  statement = Statement() {stmts.add(statement);}
2777    | statement = htmlBlock() {stmts.add(statement);})*
2778    {endStatements = SimpleCharStream.getPosition();}
2779    (elseifStatement = ElseIfStatementColon() {elseIfList.add(elseifStatement);})*
2780    [elseStatement = ElseStatementColon()]
2781
2782   {try {
2783   setMarker(fileToParse,
2784             "Ugly syntax detected, you should if () {...} instead of if (): ... endif;",
2785             start,
2786             end,
2787             INFO,
2788             "Line " + token.beginLine);
2789   } catch (CoreException e) {
2790     PHPeclipsePlugin.log(e);
2791   }}
2792   try {
2793     <ENDIF>
2794   } catch (ParseException e) {
2795     errorMessage = "'endif' expected";
2796     errorLevel   = ERROR;
2797     errorStart = SimpleCharStream.getPosition() - e.currentToken.next.image.length() + 1;
2798     errorEnd   = SimpleCharStream.getPosition() + 1;
2799     throw e;
2800   }
2801   try {
2802     <SEMICOLON>
2803   } catch (ParseException e) {
2804     errorMessage = "';' expected after 'endif' keyword";
2805     errorLevel   = ERROR;
2806     errorStart = SimpleCharStream.getPosition() - e.currentToken.next.image.length() + 1;
2807     errorEnd   = SimpleCharStream.getPosition() + 1;
2808     throw e;
2809   }
2810     {
2811     elseIfs = new ElseIf[elseIfList.size()];
2812     elseIfList.toArray(elseIfs);
2813     if (stmts.size() == 1) {
2814       return new IfStatement(condition,
2815                              (Statement) stmts.get(0),
2816                               elseIfs,
2817                               elseStatement,
2818                               pos,
2819                               SimpleCharStream.getPosition());
2820     } else {
2821       statementsArray = new Statement[stmts.size()];
2822       stmts.toArray(statementsArray);
2823       return new IfStatement(condition,
2824                              new Block(statementsArray,pos,endStatements),
2825                              elseIfs,
2826                              elseStatement,
2827                              pos,
2828                              SimpleCharStream.getPosition());
2829     }
2830     }
2831
2832 |
2833   (stmt = Statement() | stmt = htmlBlock())
2834   ( LOOKAHEAD(1) elseifStatement = ElseIfStatement() {elseIfList.add(elseifStatement);})*
2835   [ LOOKAHEAD(1)
2836     <ELSE>
2837     try {
2838       {pos = SimpleCharStream.getPosition();}
2839       statement = Statement()
2840       {elseStatement = new Else(statement,pos,SimpleCharStream.getPosition());}
2841     } catch (ParseException e) {
2842       if (errorMessage != null) {
2843         throw e;
2844       }
2845       errorMessage = "unexpected token '"+e.currentToken.next.image+"', a statement was expected";
2846       errorLevel   = ERROR;
2847       errorStart = SimpleCharStream.getPosition() - e.currentToken.next.image.length() + 1;
2848       errorEnd   = SimpleCharStream.getPosition() + 1;
2849       throw e;
2850     }
2851   ]
2852   {
2853     elseIfs = new ElseIf[elseIfList.size()];
2854     elseIfList.toArray(elseIfs);
2855     return new IfStatement(condition,
2856                            stmt,
2857                            elseIfs,
2858                            elseStatement,
2859                            pos,
2860                            SimpleCharStream.getPosition());}
2861 }
2862
2863 ElseIf ElseIfStatementColon() :
2864 {
2865   final Expression condition;
2866   Statement statement;
2867   final ArrayList list = new ArrayList();
2868   final int pos = SimpleCharStream.getPosition();
2869 }
2870 {
2871   <ELSEIF> condition = Condition("elseif")
2872   <COLON> (  statement = Statement() {list.add(statement);}
2873            | statement = htmlBlock() {list.add(statement);})*
2874   {
2875   final Statement[] stmtsArray = new Statement[list.size()];
2876   list.toArray(stmtsArray);
2877   return new ElseIf(condition,stmtsArray ,pos,SimpleCharStream.getPosition());}
2878 }
2879
2880 Else ElseStatementColon() :
2881 {
2882   Statement statement;
2883   final ArrayList list = new ArrayList();
2884   final int pos = SimpleCharStream.getPosition();
2885 }
2886 {
2887   <ELSE> <COLON> (  statement = Statement() {list.add(statement);}
2888                   | statement = htmlBlock() {list.add(statement);})*
2889   {
2890   final Statement[] stmtsArray = new Statement[list.size()];
2891   list.toArray(stmtsArray);
2892   return new Else(stmtsArray,pos,SimpleCharStream.getPosition());}
2893 }
2894
2895 ElseIf ElseIfStatement() :
2896 {
2897   final Expression condition;
2898   final Statement statement;
2899   final ArrayList list = new ArrayList();
2900   final int pos = SimpleCharStream.getPosition();
2901 }
2902 {
2903   <ELSEIF> condition = Condition("elseif") statement = Statement() {list.add(statement);/*todo:do better*/}
2904   {
2905   final Statement[] stmtsArray = new Statement[list.size()];
2906   list.toArray(stmtsArray);
2907   return new ElseIf(condition,stmtsArray,pos,SimpleCharStream.getPosition());}
2908 }
2909
2910 WhileStatement WhileStatement() :
2911 {
2912   final Expression condition;
2913   final Statement action;
2914   final int pos = SimpleCharStream.getPosition();
2915 }
2916 {
2917   <WHILE>
2918     condition = Condition("while")
2919     action    = WhileStatement0(pos,pos + 5)
2920     {return new WhileStatement(condition,action,pos,SimpleCharStream.getPosition());}
2921 }
2922
2923 Statement WhileStatement0(final int start, final int end) :
2924 {
2925   Statement statement;
2926   final ArrayList stmts = new ArrayList();
2927   final int pos = SimpleCharStream.getPosition();
2928 }
2929 {
2930   <COLON> (statement = Statement() {stmts.add(statement);})*
2931   {try {
2932   setMarker(fileToParse,
2933             "Ugly syntax detected, you should while () {...} instead of while (): ... endwhile;",
2934             start,
2935             end,
2936             INFO,
2937             "Line " + token.beginLine);
2938   } catch (CoreException e) {
2939     PHPeclipsePlugin.log(e);
2940   }}
2941   try {
2942     <ENDWHILE>
2943   } catch (ParseException e) {
2944     errorMessage = "'endwhile' expected";
2945     errorLevel   = ERROR;
2946     errorStart = SimpleCharStream.getPosition() - e.currentToken.next.image.length() + 1;
2947     errorEnd   = SimpleCharStream.getPosition() + 1;
2948     throw e;
2949   }
2950   try {
2951     <SEMICOLON>
2952     {
2953     final Statement[] stmtsArray = new Statement[stmts.size()];
2954     stmts.toArray(stmtsArray);
2955     return new Block(stmtsArray,pos,SimpleCharStream.getPosition());}
2956   } catch (ParseException e) {
2957     errorMessage = "';' expected after 'endwhile' keyword";
2958     errorLevel   = ERROR;
2959     errorStart = SimpleCharStream.getPosition() - e.currentToken.next.image.length() + 1;
2960     errorEnd   = SimpleCharStream.getPosition() + 1;
2961     throw e;
2962   }
2963 |
2964   statement = Statement()
2965   {return statement;}
2966 }
2967
2968 DoStatement DoStatement() :
2969 {
2970   final Statement action;
2971   final Expression condition;
2972   final Token token, token2;
2973 }
2974 {
2975   token = <DO> action = Statement() <WHILE> condition = Condition("while")
2976   try {
2977     token2 = <SEMICOLON>
2978     {return new DoStatement(condition,action,token.sourceStart,token2.sourceEnd);}
2979   } catch (ParseException e) {
2980     errorMessage = "unexpected token : '"+ e.currentToken.next.image +"'. A ';' was expected";
2981     errorLevel   = ERROR;
2982     errorStart = SimpleCharStream.getPosition() - e.currentToken.next.image.length() + 1;
2983     errorEnd   = SimpleCharStream.getPosition() + 1;
2984     throw e;
2985   }
2986 }
2987
2988 ForeachStatement ForeachStatement() :
2989 {
2990   Statement statement;
2991   Expression expression;
2992   ArrayVariableDeclaration variable;
2993   Token token;
2994 }
2995 {
2996   token = <FOREACH>
2997     try {
2998     <LPAREN>
2999   } catch (ParseException e) {
3000     errorMessage = "'(' expected after 'foreach' keyword";
3001     errorLevel   = ERROR;
3002     errorStart = SimpleCharStream.getPosition() - e.currentToken.next.image.length() + 1;
3003     errorEnd   = SimpleCharStream.getPosition() + 1;
3004     throw e;
3005   }
3006   try {
3007     expression = Expression()
3008   } catch (ParseException e) {
3009     errorMessage = "variable expected";
3010     errorLevel   = ERROR;
3011     errorStart = SimpleCharStream.getPosition() - e.currentToken.next.image.length() + 1;
3012     errorEnd   = SimpleCharStream.getPosition() + 1;
3013     throw e;
3014   }
3015   try {
3016     <AS>
3017   } catch (ParseException e) {
3018     errorMessage = "'as' expected";
3019     errorLevel   = ERROR;
3020     errorStart = SimpleCharStream.getPosition() - e.currentToken.next.image.length() + 1;
3021     errorEnd   = SimpleCharStream.getPosition() + 1;
3022     throw e;
3023   }
3024   try {
3025     variable = ArrayVariable()
3026   } catch (ParseException e) {
3027     errorMessage = "variable expected";
3028     errorLevel   = ERROR;
3029     errorStart = SimpleCharStream.getPosition() - e.currentToken.next.image.length() + 1;
3030     errorEnd   = SimpleCharStream.getPosition() + 1;
3031     throw e;
3032   }
3033   try {
3034     <RPAREN>
3035   } catch (ParseException e) {
3036     errorMessage = "')' expected after 'foreach' keyword";
3037     errorLevel   = ERROR;
3038     errorStart = SimpleCharStream.getPosition() - e.currentToken.next.image.length() + 1;
3039     errorEnd   = SimpleCharStream.getPosition() + 1;
3040     throw e;
3041   }
3042   try {
3043     statement = Statement()
3044   } catch (ParseException e) {
3045     if (errorMessage != null) throw e;
3046     errorMessage = "statement expected";
3047     errorLevel   = ERROR;
3048     errorStart = SimpleCharStream.getPosition() - e.currentToken.next.image.length() + 1;
3049     errorEnd   = SimpleCharStream.getPosition() + 1;
3050     throw e;
3051   }
3052   {return new ForeachStatement(expression,
3053                                variable,
3054                                statement,
3055                                token.sourceStart,
3056                                statement.sourceEnd);}
3057
3058 }
3059
3060 /**
3061  * a for declaration.
3062  * @return a node representing the for statement
3063  */
3064 ForStatement ForStatement() :
3065 {
3066 final Token token,token2;
3067 final int pos = SimpleCharStream.getPosition();
3068 Expression[] initializations = null;
3069 Expression condition = null;
3070 Expression[] increments = null;
3071 Statement action;
3072 final ArrayList list = new ArrayList();
3073 }
3074 {
3075   token = <FOR>
3076   try {
3077     <LPAREN>
3078   } catch (ParseException e) {
3079     errorMessage = "'(' expected after 'for' keyword";
3080     errorLevel   = ERROR;
3081     errorStart = token.sourceEnd;
3082     errorEnd   = token.sourceEnd +1;
3083     processParseExceptionDebug(e);
3084   }
3085      [ initializations = ForInit() ] <SEMICOLON>
3086      [ condition = Expression() ] <SEMICOLON>
3087      [ increments = StatementExpressionList() ] <RPAREN>
3088     (
3089       action = Statement()
3090       {return new ForStatement(initializations,
3091                                condition,
3092                                increments,
3093                                action,
3094                                token.sourceStart,
3095                                action.sourceEnd);}
3096     |
3097       <COLON>
3098       (action = Statement() {list.add(action);})*
3099       {
3100         try {
3101         setMarker(fileToParse,
3102                   "Ugly syntax detected, you should for () {...} instead of for (): ... endfor;",
3103                   token.sourceStart,
3104                   token.sourceEnd,
3105                   INFO,
3106                   "Line " + token.beginLine);
3107         } catch (CoreException e) {
3108           PHPeclipsePlugin.log(e);
3109         }
3110       }
3111       try {
3112         <ENDFOR>
3113       } catch (ParseException e) {
3114         errorMessage = "'endfor' expected";
3115         errorLevel   = ERROR;
3116         errorStart = SimpleCharStream.getPosition() - e.currentToken.next.image.length() + 1;
3117         errorEnd   = SimpleCharStream.getPosition() + 1;
3118         throw e;
3119       }
3120       try {
3121         token2 = <SEMICOLON>
3122         {
3123         final Statement[] stmtsArray = new Statement[list.size()];
3124         list.toArray(stmtsArray);
3125         return new ForStatement(initializations,
3126                                 condition,
3127                                 increments,
3128                                 new Block(stmtsArray,
3129                                           stmtsArray[0].sourceStart,
3130                                           stmtsArray[stmtsArray.length-1].sourceEnd),
3131                                 token.sourceStart,
3132                                 token2.sourceEnd);}
3133       } catch (ParseException e) {
3134         errorMessage = "';' expected after 'endfor' keyword";
3135         errorLevel   = ERROR;
3136         errorStart = SimpleCharStream.getPosition() - e.currentToken.next.image.length() + 1;
3137         errorEnd   = SimpleCharStream.getPosition() + 1;
3138         throw e;
3139       }
3140     )
3141 }
3142
3143 Expression[] ForInit() :
3144 {
3145   final Expression[] exprs;
3146 }
3147 {
3148   LOOKAHEAD(LocalVariableDeclaration())
3149   exprs = LocalVariableDeclaration()
3150   {return exprs;}
3151 |
3152   exprs = StatementExpressionList()
3153   {return exprs;}
3154 }
3155
3156 Expression[] StatementExpressionList() :
3157 {
3158   final ArrayList list = new ArrayList();
3159   final Expression expr;
3160 }
3161 {
3162   expr = Expression()   {list.add(expr);}
3163   (<COMMA> Expression() {list.add(expr);})*
3164   {
3165     final Expression[] exprsArray = new Expression[list.size()];
3166     list.toArray(exprsArray);
3167     return exprsArray;
3168   }
3169 }
3170
3171 Continue ContinueStatement() :
3172 {
3173   Expression expr = null;
3174   final Token token,token2;
3175 }
3176 {
3177   token = <CONTINUE> [ expr = Expression() ]
3178   try {
3179     token2 = <SEMICOLON>
3180     {return new Continue(expr,token.sourceStart,token2.sourceEnd);}
3181   } catch (ParseException e) {
3182     errorMessage = "';' expected after 'continue' statement";
3183     errorLevel   = ERROR;
3184     errorStart = SimpleCharStream.getPosition() - e.currentToken.next.image.length() + 1;
3185     errorEnd   = SimpleCharStream.getPosition() + 1;
3186     throw e;
3187   }
3188 }
3189
3190 ReturnStatement ReturnStatement() :
3191 {
3192   Expression expr = null;
3193   final Token token,token2;
3194 }
3195 {
3196   token = <RETURN> [ expr = Expression() ]
3197   try {
3198     token2 = <SEMICOLON>
3199     {return new ReturnStatement(expr,token.sourceStart,token2.sourceEnd);}
3200   } catch (ParseException e) {
3201     errorMessage = "';' expected after 'return' statement";
3202     errorLevel   = ERROR;
3203     errorStart = SimpleCharStream.getPosition() - e.currentToken.next.image.length() + 1;
3204     errorEnd   = SimpleCharStream.getPosition() + 1;
3205     throw e;
3206  }
3207 }
3208