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