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