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