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