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