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