9e3fc1d418fbd705f0fe5120d046667f4141b9fd
[phpeclipse.git] / net.sourceforge.phpeclipse / src / test / PHPParser.jj
1 options {
2   LOOKAHEAD = 1;
3   CHOICE_AMBIGUITY_CHECK = 2;
4   OTHER_AMBIGUITY_CHECK = 1;
5   STATIC = true;
6   DEBUG_PARSER = false;
7   DEBUG_LOOKAHEAD = false;
8   DEBUG_TOKEN_MANAGER = false;
9   OPTIMIZE_TOKEN_MANAGER = false;
10   ERROR_REPORTING = true;
11   JAVA_UNICODE_ESCAPE = false;
12   UNICODE_INPUT = false;
13   IGNORE_CASE = true;
14   USER_TOKEN_MANAGER = false;
15   USER_CHAR_STREAM = false;
16   BUILD_PARSER = true;
17   BUILD_TOKEN_MANAGER = true;
18   SANITY_CHECK = true;
19   FORCE_LA_CHECK = false;
20 }
21
22 PARSER_BEGIN(PHPParser)
23 package test;
24
25 import org.eclipse.core.resources.IFile;
26 import org.eclipse.core.resources.IMarker;
27 import org.eclipse.core.runtime.CoreException;
28 import org.eclipse.ui.texteditor.MarkerUtilities;
29 import org.eclipse.jface.preference.IPreferenceStore;
30
31 import java.util.Hashtable;
32 import java.io.StringReader;
33 import java.text.MessageFormat;
34
35 import net.sourceforge.phpeclipse.actions.PHPStartApacheAction;
36 import net.sourceforge.phpeclipse.PHPeclipsePlugin;
37 import net.sourceforge.phpdt.internal.compiler.parser.PHPOutlineInfo;
38 import net.sourceforge.phpdt.internal.compiler.parser.PHPSegmentWithChildren;
39 import net.sourceforge.phpdt.internal.compiler.parser.PHPFunctionDeclaration;
40 import net.sourceforge.phpdt.internal.compiler.parser.PHPClassDeclaration;
41 import net.sourceforge.phpdt.internal.compiler.parser.PHPVarDeclaration;
42 import net.sourceforge.phpdt.internal.compiler.parser.PHPReqIncDeclaration;
43
44 /**
45  * A new php parser.
46  * This php parser is inspired by the Java 1.2 grammar example 
47  * given with JavaCC. You can get JavaCC at http://www.webgain.com
48  * You can test the parser with the PHPParserTestCase2.java
49  * @author Matthieu Casanova
50  */
51 public class PHPParser extends PHPParserSuperclass {
52
53   private static IFile fileToParse;
54
55   /** The current segment */
56   private static PHPSegmentWithChildren currentSegment;
57
58   private static final String PARSE_ERROR_STRING = "Parse error"; //$NON-NLS-1$
59   private static final String PARSE_WARNING_STRING = "Warning"; //$NON-NLS-1$
60   PHPOutlineInfo outlineInfo;
61   private static int errorLevel = ERROR;
62   private static String errorMessage;
63
64   public PHPParser() {
65   }
66
67   public void setFileToParse(IFile fileToParse) {
68     this.fileToParse = fileToParse;
69   }
70
71   public PHPParser(IFile fileToParse) {
72     this(new StringReader(""));
73     this.fileToParse = fileToParse;
74   }
75
76   public void phpParserTester(String strEval) throws CoreException, ParseException {
77     PHPParserTokenManager.SwitchTo(PHPParserTokenManager.PHPPARSING);
78     StringReader stream = new StringReader(strEval);
79     if (jj_input_stream == null) {
80       jj_input_stream = new SimpleCharStream(stream, 1, 1);
81     }
82     ReInit(new StringReader(strEval));
83     phpTest();
84   }
85
86   public void htmlParserTester(String strEval) throws CoreException, ParseException {
87     StringReader stream = new StringReader(strEval);
88     if (jj_input_stream == null) {
89       jj_input_stream = new SimpleCharStream(stream, 1, 1);
90     }
91     ReInit(stream);
92     phpFile();
93   }
94
95   public PHPOutlineInfo parseInfo(Object parent, String s) {
96     outlineInfo = new PHPOutlineInfo(parent);
97     currentSegment = outlineInfo.getDeclarations();
98     StringReader stream = new StringReader(s);
99     if (jj_input_stream == null) {
100       jj_input_stream = new SimpleCharStream(stream, 1, 1);
101     }
102     ReInit(stream);
103     try {
104       parse();
105     } catch (ParseException e) {
106       processParseException(e);
107     }
108     return outlineInfo;
109   }
110
111   /**
112    * This method will process the parse exception.
113    * If the error message is null, the parse exception wasn't catched and a trace is written in the log
114    * @param e the ParseException
115    */
116   private static void processParseException(final ParseException e) {
117     if (errorMessage == null) {
118       PHPeclipsePlugin.log(e);
119       errorMessage = "this exception wasn't handled by the parser please tell us how to reproduce it";
120     }
121     setMarker(e);
122     errorMessage = null;
123   }
124
125   /**
126    * Create marker for the parse error
127    */
128   private static void setMarker(ParseException e) {
129     try {
130       setMarker(fileToParse,
131                 errorMessage,
132                 jj_input_stream.tokenBegin,
133                 jj_input_stream.tokenBegin + e.currentToken.image.length(),
134                 errorLevel,
135                 "Line " + e.currentToken.beginLine);
136     } catch (CoreException e2) {
137       PHPeclipsePlugin.log(e2);
138     }
139   }
140
141   /**
142    * Create markers according to the external parser output
143    */
144   private static void createMarkers(String output, IFile file) throws CoreException {
145     // delete all markers
146     file.deleteMarkers(IMarker.PROBLEM, false, 0);
147
148     int indx = 0;
149     int brIndx = 0;
150     boolean flag = true;
151     while ((brIndx = output.indexOf("<br />", indx)) != -1) {
152       // newer php error output (tested with 4.2.3)
153       scanLine(output, file, indx, brIndx);
154       indx = brIndx + 6;
155       flag = false;
156     }
157     if (flag) {
158       while ((brIndx = output.indexOf("<br>", indx)) != -1) {
159         // older php error output (tested with 4.2.3)
160         scanLine(output, file, indx, brIndx);
161         indx = brIndx + 4;
162       }
163     }
164   }
165
166   private static void scanLine(String output, IFile file, int indx, int brIndx) throws CoreException {
167     String current;
168     StringBuffer lineNumberBuffer = new StringBuffer(10);
169     char ch;
170     current = output.substring(indx, brIndx);
171
172     if (current.indexOf(PARSE_WARNING_STRING) != -1 || current.indexOf(PARSE_ERROR_STRING) != -1) {
173       int onLine = current.indexOf("on line <b>");
174       if (onLine != -1) {
175         lineNumberBuffer.delete(0, lineNumberBuffer.length());
176         for (int i = onLine; i < current.length(); i++) {
177           ch = current.charAt(i);
178           if ('0' <= ch && '9' >= ch) {
179             lineNumberBuffer.append(ch);
180           }
181         }
182
183         int lineNumber = Integer.parseInt(lineNumberBuffer.toString());
184
185         Hashtable attributes = new Hashtable();
186
187         current = current.replaceAll("\n", "");
188         current = current.replaceAll("<b>", "");
189         current = current.replaceAll("</b>", "");
190         MarkerUtilities.setMessage(attributes, current);
191
192         if (current.indexOf(PARSE_ERROR_STRING) != -1)
193           attributes.put(IMarker.SEVERITY, new Integer(IMarker.SEVERITY_ERROR));
194         else if (current.indexOf(PARSE_WARNING_STRING) != -1)
195           attributes.put(IMarker.SEVERITY, new Integer(IMarker.SEVERITY_WARNING));
196         else
197           attributes.put(IMarker.SEVERITY, new Integer(IMarker.SEVERITY_INFO));
198         MarkerUtilities.setLineNumber(attributes, lineNumber);
199         MarkerUtilities.createMarker(file, attributes, IMarker.PROBLEM);
200       }
201     }
202   }
203
204   public void parse(String s) throws CoreException {
205     ReInit(new StringReader(s));
206     try {
207       parse();
208     } catch (ParseException e) {
209       processParseException(e);
210     }
211   }
212
213   /**
214    * Call the php parse command ( php -l -f &lt;filename&gt; )
215    * and create markers according to the external parser output
216    */
217   public static void phpExternalParse(IFile file) {
218     IPreferenceStore store = PHPeclipsePlugin.getDefault().getPreferenceStore();
219     String filename = file.getLocation().toString();
220
221     String[] arguments = { filename };
222     MessageFormat form = new MessageFormat(store.getString(PHPeclipsePlugin.EXTERNAL_PARSER_PREF));
223     String command = form.format(arguments);
224
225     String parserResult = PHPStartApacheAction.getParserOutput(command, "External parser: ");
226
227     try {
228       // parse the buffer to find the errors and warnings
229       createMarkers(parserResult, file);
230     } catch (CoreException e) {
231       PHPeclipsePlugin.log(e);
232     }
233   }
234
235   public void parse() throws ParseException {
236           phpFile();
237   }
238 }
239
240 PARSER_END(PHPParser)
241
242 <DEFAULT> TOKEN :
243 {
244   <PHPSTART : "<?php" | "<?"> : PHPPARSING
245 }
246
247 <PHPPARSING> TOKEN :
248 {
249   <PHPEND :"?>"> : DEFAULT
250 }
251
252 <DEFAULT> SKIP :
253 {
254  < ~[] >
255 }
256
257
258 /* WHITE SPACE */
259
260 <PHPPARSING> SKIP :
261 {
262   " "
263 | "\t"
264 | "\n"
265 | "\r"
266 | "\f"
267 }
268
269 /* COMMENTS */
270
271 <PHPPARSING> MORE :
272 {
273   "//" : IN_SINGLE_LINE_COMMENT
274 |
275   <"/**" ~["/"]> { input_stream.backup(1); } : IN_FORMAL_COMMENT
276 |
277   "/*" : IN_MULTI_LINE_COMMENT
278 }
279
280 <IN_SINGLE_LINE_COMMENT>
281 SPECIAL_TOKEN :
282 {
283   <SINGLE_LINE_COMMENT: "\n" | "\r" | "\r\n" | "?>" > : PHPPARSING
284 }
285
286 <IN_FORMAL_COMMENT>
287 SPECIAL_TOKEN :
288 {
289   <FORMAL_COMMENT: "*/" > : PHPPARSING
290 }
291
292 <IN_MULTI_LINE_COMMENT>
293 SPECIAL_TOKEN :
294 {
295   <MULTI_LINE_COMMENT: "*/" > : PHPPARSING
296 }
297
298 <IN_SINGLE_LINE_COMMENT,IN_FORMAL_COMMENT,IN_MULTI_LINE_COMMENT>
299 MORE :
300 {
301   < ~[] >
302 }
303
304 /* KEYWORDS */
305 <PHPPARSING> TOKEN :
306 {
307   <CLASS    : "class">
308 | <FUNCTION : "function">
309 | <VAR      : "var">
310 | <IF       : "if">
311 | <ELSEIF   : "elseif">
312 | <ELSE     : "else">
313 | <ARRAY    : "array">
314 }
315
316 /* LANGUAGE CONSTRUCT */
317 <PHPPARSING> TOKEN :
318 {
319   <PRINT : "print">
320 | <ECHO : "echo">
321 | <INCLUDE : "include">
322 | <REQUIRE : "require">
323 | <INCLUDE_ONCE : "include_once">
324 | <REQUIRE_ONCE : "require_once">
325 | <GLOBAL : "global">
326 | <STATIC : "static">
327 | <CLASSACCESS: "->">
328 | <STATICCLASSACCESS: "::">
329 | <ARRAYASSIGN: "=>">
330 }
331
332 /* RESERVED WORDS AND LITERALS */
333
334 <PHPPARSING> TOKEN :
335 {
336   < BREAK: "break" >
337 | < CASE: "case" >
338 | < CONST: "const" >
339 | < CONTINUE: "continue" >
340 | < _DEFAULT: "default" >
341 | < DO: "do" >
342 | < EXTENDS: "extends" >
343 | < FALSE: "false" >
344 | < FOR: "for" >
345 | < GOTO: "goto" >
346 | < NEW: "new" >
347 | < NULL: "null" >
348 | < RETURN: "return" >
349 | < SUPER: "super" >
350 | < SWITCH: "switch" >
351 | < THIS: "this" >
352 | < TRUE: "true" >
353 | < WHILE: "while" >
354 | < ENDWHILE : "endwhile" >
355 }
356
357 /* TYPES */
358
359 <PHPPARSING> TOKEN :
360 {
361   <STRING : "string">
362 | <OBJECT : "object">
363 | <BOOL : "bool">
364 | <BOOLEAN : "boolean">
365 | <REAL : "real">
366 | <DOUBLE : "double">
367 | <FLOAT : "float">
368 | <INT : "int">
369 | <INTEGER : "integer">
370 }
371
372 <PHPPARSING> TOKEN :
373 {
374   < _ORL : "OR" >
375 | < _ANDL: "AND">
376 }
377
378 /* LITERALS */
379
380 <PHPPARSING> TOKEN :
381 {
382   < INTEGER_LITERAL:
383         <DECIMAL_LITERAL> (["l","L"])?
384       | <HEX_LITERAL> (["l","L"])?
385       | <OCTAL_LITERAL> (["l","L"])?
386   >
387 |
388   < #DECIMAL_LITERAL: ["1"-"9"] (["0"-"9"])* >
389 |
390   < #HEX_LITERAL: "0" ["x","X"] (["0"-"9","a"-"f","A"-"F"])+ >
391 |
392   < #OCTAL_LITERAL: "0" (["0"-"7"])* >
393 |
394   < FLOATING_POINT_LITERAL:
395         (["0"-"9"])+ "." (["0"-"9"])* (<EXPONENT>)? (["f","F","d","D"])?
396       | "." (["0"-"9"])+ (<EXPONENT>)? (["f","F","d","D"])?
397       | (["0"-"9"])+ <EXPONENT> (["f","F","d","D"])?
398       | (["0"-"9"])+ (<EXPONENT>)? ["f","F","d","D"]
399   >
400 |
401   < #EXPONENT: ["e","E"] (["+","-"])? (["0"-"9"])+ >
402 |
403   < STRING_LITERAL: (<STRING_1> | <STRING_2> | <STRING_3>)>
404 |    < STRING_1:
405       "\""
406       (
407         ~["\""]
408         |
409         "\\\""
410       )*
411       "\""
412     >
413 |    < STRING_2:
414       "'"
415       (
416       ~["'"]
417        |
418        "\\'"
419       )*
420
421       "'"
422     >
423 |   < STRING_3:
424       "`"
425       (
426         ~["`"]
427       |
428         "\\`"
429       )*
430       "`"
431     >
432 }
433
434 /* IDENTIFIERS */
435
436 <PHPPARSING> TOKEN :
437 {
438   < IDENTIFIER: (<LETTER>|<SPECIAL>) (<LETTER>|<DIGIT>|<SPECIAL>)* >
439 |
440   < #LETTER:
441       ["a"-"z"] | ["A"-"Z"]
442   >
443 |
444   < #DIGIT:
445       ["0"-"9"]
446   >
447 |
448   < #SPECIAL:
449     "_" | ["\u007f"-"\u00ff"]
450   >
451 }
452
453 /* SEPARATORS */
454
455 <PHPPARSING> TOKEN :
456 {
457   < LPAREN: "(" >
458 | < RPAREN: ")" >
459 | < LBRACE: "{" >
460 | < RBRACE: "}" >
461 | < LBRACKET: "[" >
462 | < RBRACKET: "]" >
463 | < SEMICOLON: ";" >
464 | < COMMA: "," >
465 | < DOT: "." >
466 }
467
468 /* OPERATORS */
469
470 <PHPPARSING> TOKEN :
471 {
472   <AT     : "@">
473 | <DOLLAR : "$">
474 | <ASSIGN: "=" >
475 | <GT: ">" >
476 | <LT: "<" >
477 | <BANG: "!" >
478 | <HOOK: "?" >
479 | <COLON: ":" >
480 | <EQ: "==" >
481 | <LE: "<=" >
482 | <GE: ">=" >
483 | <NE: "!=" >
484 | <SC_OR: "||" >
485 | <SC_AND: "&&" >
486 | <INCR: "++" >
487 | <DECR: "--" >
488 | <PLUS: "+" >
489 | <MINUS: "-" >
490 | <STAR: "*" >
491 | <SLASH: "/" >
492 | <BIT_AND: "&" >
493 | <BIT_OR: "|" >
494 | <XOR: "^" >
495 | <REM: "%" >
496 | <LSHIFT: "<<" >
497 | <RSIGNEDSHIFT: ">>" >
498 | <RUNSIGNEDSHIFT: ">>>" >
499 | <PLUSASSIGN: "+=" >
500 | <MINUSASSIGN: "-=" >
501 | <STARASSIGN: "*=" >
502 | <SLASHASSIGN: "/=" >
503 | <ANDASSIGN: "&=" >
504 | <ORASSIGN: "|=" >
505 | <XORASSIGN: "^=" >
506 | <DOTASSIGN: ".=" >
507 | <REMASSIGN: "%=" >
508 | <LSHIFTASSIGN: "<<=" >
509 | <RSIGNEDSHIFTASSIGN: ">>=" >
510 | <BANGDOUBLEEQUAL: "!==" >
511 | <TRIPLEEQUAL: "===" >
512 | <TILDEEQUAL: "~=" >
513 }
514
515 <PHPPARSING> TOKEN :
516 {
517   < DOLLAR_ID: <DOLLAR> <IDENTIFIER>  >
518 }
519
520 /*****************************************
521  * THE JAVA LANGUAGE GRAMMAR STARTS HERE *
522  *****************************************/
523
524 /*
525  * Program structuring syntax follows.
526  */
527
528 void phpTest() :
529 {}
530 {
531   Php()
532   <EOF>
533 }
534
535 void phpFile() :
536 {}
537 {
538   try {
539   (<PHPSTART> Php() <PHPEND>)*
540   <EOF>
541   } catch (TokenMgrError e) {
542     errorMessage = e.getMessage();
543     errorLevel   = ERROR;
544     throw generateParseException();
545   }
546 }
547
548 void Php() :
549 {}
550 {
551   (BlockStatement())*
552 }
553
554 void ClassDeclaration() :
555 {
556   PHPClassDeclaration classDeclaration;
557   Token className;
558   int pos = jj_input_stream.bufpos;
559 }
560 {
561   <CLASS> className = <IDENTIFIER> [ <EXTENDS> <IDENTIFIER> ]
562   {
563     classDeclaration = new PHPClassDeclaration(currentSegment,className.image,pos);
564     currentSegment.add(classDeclaration);
565     currentSegment = classDeclaration;
566   }
567   ClassBody()
568   {
569     currentSegment = (PHPSegmentWithChildren) currentSegment.getParent();
570   }
571 }
572
573 void ClassBody() :
574 {}
575 {
576   try {
577     <LBRACE>
578   } catch (ParseException e) {
579     errorMessage = "'{' expected";
580     errorLevel   = ERROR;
581     throw e;
582   }
583   ( ClassBodyDeclaration() )*
584   try {
585     <RBRACE>
586   } catch (ParseException e) {
587     errorMessage = "'var', 'function' or '}' expected";
588     errorLevel   = ERROR;
589     throw e;
590   }
591 }
592
593 void ClassBodyDeclaration() :
594 {}
595 {
596   MethodDeclaration()
597 |
598   FieldDeclaration()
599 }
600
601 void FieldDeclaration() :
602 {
603   PHPVarDeclaration variableDeclaration;
604 }
605 {
606   <VAR> variableDeclaration = VariableDeclarator()
607   {currentSegment.add(variableDeclaration);}
608   ( <COMMA>
609     variableDeclaration = VariableDeclarator()
610     {currentSegment.add(variableDeclaration);}
611   )*
612   try {
613     <SEMICOLON>
614   } catch (ParseException e) {
615     errorMessage = "';' expected after variable declaration";
616     errorLevel   = ERROR;
617     throw e;
618   }
619 }
620
621 PHPVarDeclaration VariableDeclarator() :
622 {
623   String varName;
624   String varValue = null;
625   int pos = jj_input_stream.bufpos;
626 }
627 {
628   varName = VariableDeclaratorId()
629   [
630     <ASSIGN>
631     try {
632       varValue = VariableInitializer()
633     } catch (ParseException e) {
634       errorMessage = "Literal expression expected in variable initializer";
635       errorLevel   = ERROR;
636       throw e;
637     }
638   ]
639   {
640     if (varValue == null) {
641       return new PHPVarDeclaration(currentSegment,varName,pos);
642     }
643     return new PHPVarDeclaration(currentSegment,varName,pos,varValue);
644   }
645 }
646
647 String VariableDeclaratorId() :
648 {
649   String expr;
650   StringBuffer buff = new StringBuffer();
651 }
652 {
653   try {
654     expr = Variable()
655     {buff.append(expr);}
656     ( LOOKAHEAD(2) expr = VariableSuffix()
657     {buff.append(expr);}
658     )*
659     {return buff.toString();}
660   } catch (ParseException e) {
661     errorMessage = "'$' expected for variable identifier";
662     errorLevel   = ERROR;
663     throw e;
664   }
665 }
666
667 String Variable():
668 {
669   String expr = null;
670   Token token;
671 }
672 {
673   token = <DOLLAR_ID> [<LBRACE> expr = Expression() <RBRACE>]
674   {
675     if (expr == null) {
676       return token.image;
677     }
678     return token + "{" + expr + "}";
679   }
680 |
681   <DOLLAR> expr = VariableName()
682   {return "$" + expr;}
683 }
684
685 String VariableName():
686 {
687 String expr = null;
688 Token token;
689 }
690 {
691   <LBRACE> expr = Expression() <RBRACE>
692   {return "{"+expr+"}";}
693 |
694   token = <IDENTIFIER> [<LBRACE> expr = Expression() <RBRACE>]
695   {
696     if (expr == null) {
697       return token.image;
698     }
699     return token + "{" + expr + "}";
700   }
701 |
702   <DOLLAR> expr = VariableName()
703   {return "$" + expr;}
704 |
705   token = <DOLLAR_ID> [expr = VariableName()]
706   {
707   if (expr == null) {
708     return token.image;
709   }
710   return token.image + expr;
711   }
712 }
713
714 String VariableInitializer() :
715 {
716   String expr;
717   Token token;
718 }
719 {
720   expr = Literal()
721   {return expr;}
722 |
723   <MINUS> (token = <INTEGER_LITERAL> | token = <FLOATING_POINT_LITERAL>)
724   {return "-" + token.image;}
725 |
726   <PLUS> (token = <INTEGER_LITERAL> | token = <FLOATING_POINT_LITERAL>)
727   {return "+" + token.image;}
728 |
729   expr = ArrayDeclarator()
730   {return expr;}
731 |
732   token = <IDENTIFIER>
733   {return token.image;}
734 }
735
736 String ArrayVariable() :
737 {
738 String expr;
739 StringBuffer buff = new StringBuffer();
740 }
741 {
742   expr = Expression()
743   {buff.append(expr);}
744    [<ARRAYASSIGN> expr = Expression()
745    {buff.append("=>").append(expr);}]
746   {return buff.toString();}
747 }
748
749 String ArrayInitializer() :
750 {
751 String expr = null;
752 StringBuffer buff = new StringBuffer("(");
753 }
754 {
755   <LPAREN> [ expr = ArrayVariable()
756             {buff.append(expr);}
757             ( LOOKAHEAD(2) <COMMA> expr = ArrayVariable()
758             {buff.append(",").append(expr);}
759             )* ]
760   <RPAREN>
761   {
762     buff.append(")");
763     return buff.toString();
764   }
765 }
766
767 void MethodDeclaration() :
768 {
769   PHPFunctionDeclaration functionDeclaration;
770 }
771 {
772   <FUNCTION> functionDeclaration = MethodDeclarator()
773   {
774     currentSegment.add(functionDeclaration);
775     currentSegment = functionDeclaration;
776   }
777   Block()
778   {
779     currentSegment = (PHPSegmentWithChildren) currentSegment.getParent();
780   }
781 }
782
783 PHPFunctionDeclaration MethodDeclarator() :
784 {
785   Token identifier;
786   StringBuffer methodDeclaration = new StringBuffer();
787   String formalParameters;
788   int pos = jj_input_stream.bufpos;
789 }
790 {
791   [ <BIT_AND> {methodDeclaration.append("&");} ]
792   identifier = <IDENTIFIER>
793   {methodDeclaration.append(identifier);}
794     formalParameters = FormalParameters()
795   {
796     methodDeclaration.append(formalParameters);
797     return new PHPFunctionDeclaration(currentSegment,methodDeclaration.toString(),pos);
798   }
799 }
800
801 String FormalParameters() :
802 {
803   String expr;
804   final StringBuffer buff = new StringBuffer("(");
805 }
806 {
807   try {
808   <LPAREN>
809   } catch (ParseException e) {
810     errorMessage = "Formal parameter expected after function identifier";
811     errorLevel   = ERROR;
812     jj_consume_token(token.kind);
813   }
814             [ expr = FormalParameter()
815               {buff.append(expr);}
816             (
817                 <COMMA> expr = FormalParameter()
818                 {buff.append(",").append(expr);}
819             )*
820             ]
821   try {
822     <RPAREN>
823   } catch (ParseException e) {
824     errorMessage = "')' expected";
825     errorLevel   = ERROR;
826     throw e;
827   }
828  {
829   buff.append(")");
830   return buff.toString();
831  }
832 }
833
834 String FormalParameter() :
835 {
836   PHPVarDeclaration variableDeclaration;
837   StringBuffer buff = new StringBuffer();
838 }
839 {
840   [<BIT_AND> {buff.append("&");}] variableDeclaration = VariableDeclarator()
841   {
842     buff.append(variableDeclaration.toString());
843     return buff.toString();
844   }
845 }
846
847 String Type() :
848 {}
849 {
850   <STRING>
851   {return "string";}
852 |
853   <BOOL>
854   {return "bool";}
855 |
856   <BOOLEAN>
857   {return "boolean";}
858 |
859   <REAL>
860   {return "real";}
861 |
862   <DOUBLE>
863   {return "double";}
864 |
865   <FLOAT>
866   {return "float";}
867 |
868   <INT>
869   {return "int";}
870 |
871   <INTEGER>
872   {return "integer";}
873 }
874
875 String Expression() :
876 {
877   String expr;
878   String assignOperator = null;
879   String expr2 = null;
880 }
881 {
882   expr = PrintExpression()
883   {return expr;}
884 |
885   expr = ConditionalExpression()
886   [
887     assignOperator = AssignmentOperator()
888     try {
889       expr2 = Expression()
890     } catch (ParseException e) {
891       errorMessage = "expression expected";
892       errorLevel   = ERROR;
893       throw e;
894     }
895   ]
896   {
897     if (expr2 == null) {
898       return expr;
899     } else {
900       return expr + assignOperator + expr2;
901     }
902   }
903 }
904
905 String AssignmentOperator() :
906 {}
907 {
908   <ASSIGN>
909 {return "=";}
910 | <STARASSIGN>
911 {return "*=";}
912 | <SLASHASSIGN>
913 {return "/=";}
914 | <REMASSIGN>
915 {return "%=";}
916 | <PLUSASSIGN>
917 {return "+=";}
918 | <MINUSASSIGN>
919 {return "-=";}
920 | <LSHIFTASSIGN>
921 {return "<<=";}
922 | <RSIGNEDSHIFTASSIGN>
923 {return ">>=";}
924 | <ANDASSIGN>
925 {return "&=";}
926 | <XORASSIGN>
927 {return "|=";}
928 | <ORASSIGN>
929 {return "|=";}
930 | <DOTASSIGN>
931 {return ".=";}
932 | <TILDEEQUAL>
933 {return "~=";}
934 }
935
936 String ConditionalExpression() :
937 {
938   String expr;
939   String expr2 = null;
940   String expr3 = null;
941 }
942 {
943   expr = ConditionalOrExpression() [ <HOOK> expr2 = Expression() <COLON> expr3 = ConditionalExpression() ]
944 {
945   if (expr3 == null) {
946     return expr;
947   } else {
948     return expr + "?" + expr2 + ":" + expr3;
949   }
950 }
951 }
952
953 String ConditionalOrExpression() :
954 {
955   String expr;
956   Token operator;
957   String expr2 = null;
958   StringBuffer buff = new StringBuffer();
959 }
960 {
961   expr = ConditionalAndExpression()
962   {
963     buff.append(expr);
964   }
965   (
966     (operator = <SC_OR> | operator = <_ORL>) expr2 = ConditionalAndExpression()
967     {
968       buff.append(operator.image);
969       buff.append(expr2);
970     }
971   )*
972   {
973     return buff.toString();
974   }
975 }
976
977 String ConditionalAndExpression() :
978 {
979   String expr;
980   Token operator;
981   String expr2 = null;
982   StringBuffer buff = new StringBuffer();
983 }
984 {
985   expr = ConcatExpression()
986   {
987     buff.append(expr);
988   }
989   (
990   (operator = <SC_AND> | operator = <_ANDL>) expr2 = ConcatExpression()
991     {
992       buff.append(operator.image);
993       buff.append(expr2);
994     }
995   )*
996   {
997     return buff.toString();
998   }
999 }
1000
1001 String ConcatExpression() :
1002 {
1003   String expr;
1004   String expr2 = null;
1005   StringBuffer buff = new StringBuffer();
1006 }
1007 {
1008   expr = InclusiveOrExpression()
1009   {
1010     buff.append(expr);
1011   }
1012   (
1013   <DOT> expr2 = InclusiveOrExpression()
1014   {
1015     buff.append(".");
1016     buff.append(expr2);
1017   }
1018   )*
1019   {
1020     return buff.toString();
1021   }
1022 }
1023
1024 String InclusiveOrExpression() :
1025 {
1026   String expr;
1027   String expr2 = null;
1028   StringBuffer buff = new StringBuffer();
1029 }
1030 {
1031   expr = ExclusiveOrExpression()
1032   {
1033     buff.append(expr);
1034   }
1035   (
1036   <BIT_OR> expr2 = ExclusiveOrExpression()
1037   {
1038     buff.append("|");
1039     buff.append(expr2);
1040   }
1041   )*
1042   {
1043     return buff.toString();
1044   }
1045 }
1046
1047 String ExclusiveOrExpression() :
1048 {
1049   String expr;
1050   String expr2 = null;
1051   StringBuffer buff = new StringBuffer();
1052 }
1053 {
1054   expr = AndExpression()
1055   {
1056     buff.append(expr);
1057   }
1058   (
1059     <XOR> expr2 = AndExpression()
1060   {
1061     buff.append("^");
1062     buff.append(expr2);
1063   }
1064   )*
1065   {
1066     return buff.toString();
1067   }
1068 }
1069
1070 String AndExpression() :
1071 {
1072   String expr;
1073   String expr2 = null;
1074   StringBuffer buff = new StringBuffer();
1075 }
1076 {
1077   expr = EqualityExpression()
1078   {
1079     buff.append(expr);
1080   }
1081   (
1082     <BIT_AND> expr2 = EqualityExpression()
1083   {
1084     buff.append("&");
1085     buff.append(expr2);
1086   }
1087   )*
1088   {
1089     return buff.toString();
1090   }
1091 }
1092
1093 String EqualityExpression() :
1094 {
1095   String expr;
1096   Token operator;
1097   String expr2;
1098   StringBuffer buff = new StringBuffer();
1099 }
1100 {
1101   expr = RelationalExpression()
1102   {buff.append(expr);}
1103   (
1104   (   operator = <EQ>
1105     | operator = <NE>
1106     | operator = <BANGDOUBLEEQUAL>
1107     | operator = <TRIPLEEQUAL>
1108   )
1109   expr2 = RelationalExpression()
1110   {
1111     buff.append(operator.image);
1112     buff.append(expr2);
1113   }
1114   )*
1115   {return buff.toString();}
1116 }
1117
1118 String RelationalExpression() :
1119 {
1120   String expr;
1121   Token operator;
1122   String expr2;
1123   StringBuffer buff = new StringBuffer();
1124 }
1125 {
1126   expr = ShiftExpression()
1127   {buff.append(expr);}
1128   (
1129   ( operator = <LT> | operator = <GT> | operator = <LE> | operator = <GE> ) expr2 = ShiftExpression()
1130   {
1131     buff.append(operator.image);
1132     buff.append(expr2);
1133   }
1134   )*
1135   {return buff.toString();}
1136 }
1137
1138 String ShiftExpression() :
1139 {
1140   String expr;
1141   Token operator;
1142   String expr2;
1143   StringBuffer buff = new StringBuffer();
1144 }
1145 {
1146   expr = AdditiveExpression()
1147   {buff.append(expr);}
1148   (
1149   (operator = <LSHIFT> | operator = <RSIGNEDSHIFT> | operator = <RUNSIGNEDSHIFT> ) expr2 = AdditiveExpression()
1150   {
1151     buff.append(operator.image);
1152     buff.append(expr2);
1153   }
1154   )*
1155   {return buff.toString();}
1156 }
1157
1158 String AdditiveExpression() :
1159 {
1160   String expr;
1161   Token operator;
1162   String expr2;
1163   StringBuffer buff = new StringBuffer();
1164 }
1165 {
1166   expr = MultiplicativeExpression()
1167   {buff.append(expr);}
1168   (
1169    ( operator = <PLUS> | operator = <MINUS> ) expr2 = MultiplicativeExpression()
1170   {
1171     buff.append(operator.image);
1172     buff.append(expr2);
1173   }
1174    )*
1175   {return buff.toString();}
1176 }
1177
1178 String MultiplicativeExpression() :
1179 {
1180   String expr, expr2;
1181   Token operator;
1182   final StringBuffer buff = new StringBuffer();}
1183 {
1184   expr = UnaryExpression()
1185   {buff.append(expr);}
1186   (
1187   ( operator = <STAR> | operator = <SLASH> | operator = <REM> ) expr2 = UnaryExpression()
1188   {
1189     buff.append(operator.image);
1190     buff.append(expr2);
1191   }
1192   )*
1193   {return buff.toString();}
1194 }
1195
1196 /**
1197  * An unary expression starting with @, & or nothing
1198  */
1199 String UnaryExpression() :
1200 {
1201   String expr;
1202   Token token;
1203   final StringBuffer buff = new StringBuffer();
1204 }
1205 {
1206   token = <BIT_AND> expr = UnaryExpressionNoPrefix()
1207   {
1208     if (token == null) {
1209       return expr;
1210     }
1211     return token.image + expr;
1212   }
1213 |
1214   (<AT> {buff.append("@");})* expr = UnaryExpressionNoPrefix()
1215   {return buff.append(expr).toString();}
1216 }
1217
1218 String UnaryExpressionNoPrefix() :
1219 {
1220   String expr;
1221   Token token;
1222 }
1223 {
1224   ( token = <PLUS> | token = <MINUS> ) expr = UnaryExpression()
1225   {
1226     return token.image + expr;
1227   }
1228 |
1229   expr = PreIncrementExpression()
1230   {return expr;}
1231 |
1232   expr = PreDecrementExpression()
1233   {return expr;}
1234 |
1235   expr = UnaryExpressionNotPlusMinus()
1236   {return expr;}
1237 }
1238
1239
1240 String PreIncrementExpression() :
1241 {
1242 String expr;
1243 }
1244 {
1245   <INCR> expr = PrimaryExpression()
1246   {return "++"+expr;}
1247 }
1248
1249 String PreDecrementExpression() :
1250 {
1251 String expr;
1252 }
1253 {
1254   <DECR> expr = PrimaryExpression()
1255   {return "--"+expr;}
1256 }
1257
1258 String UnaryExpressionNotPlusMinus() :
1259 {
1260   String expr;
1261 }
1262 {
1263   <BANG> expr = UnaryExpression()
1264   {return "!" + expr;}
1265 |
1266   LOOKAHEAD( <LPAREN> Type() <RPAREN> )
1267   expr = CastExpression()
1268   {return expr;}
1269 |
1270   expr = PostfixExpression()
1271   {return expr;}
1272 |
1273   expr = Literal()
1274   {return expr;}
1275 |
1276   <LPAREN> expr = Expression()<RPAREN>
1277   {return "("+expr+")";}
1278 }
1279
1280 String CastExpression() :
1281 {
1282 String type;
1283 String expr;
1284 }
1285 {
1286   <LPAREN> type = Type() <RPAREN> expr = UnaryExpression()
1287   {return "(" + type + ")" + expr;}
1288 }
1289
1290 String PostfixExpression() :
1291 {
1292   String expr;
1293   Token operator = null;
1294 }
1295 {
1296   expr = PrimaryExpression() [ operator = <INCR> | operator = <DECR> ]
1297   {
1298     if (operator == null) {
1299       return expr;
1300     }
1301     return expr + operator.image;
1302   }
1303 }
1304
1305 String PrimaryExpression() :
1306 {
1307   Token identifier;
1308   String expr;
1309   final StringBuffer buff = new StringBuffer();
1310 }
1311 {
1312   LOOKAHEAD(2)
1313   identifier = <IDENTIFIER> <STATICCLASSACCESS> expr = ClassIdentifier()
1314   {buff.append(identifier.image).append("::").append(expr);}
1315   (
1316   expr = PrimarySuffix()
1317   {buff.append(expr);}
1318   )*
1319   {return buff.toString();}
1320 |
1321   expr = PrimaryPrefix()  {buff.append(expr);}
1322   ( expr = PrimarySuffix()  {buff.append(expr);} )*
1323   {return buff.toString();}
1324 |
1325   expr = ArrayDeclarator()
1326   {return "array" + expr;}
1327 }
1328
1329 String ArrayDeclarator() :
1330 {
1331   String expr;
1332 }
1333 {
1334   <ARRAY> expr = ArrayInitializer()
1335   {return "array" + expr;}
1336 }
1337
1338 String PrimaryPrefix() :
1339 {
1340   String expr;
1341   Token token = null;
1342 }
1343 {
1344   token = <IDENTIFIER>
1345   {return token.image;}
1346 |
1347   <NEW> expr = ClassIdentifier()
1348   {
1349     return "new " + expr;
1350   }
1351 |  
1352   expr = VariableDeclaratorId()
1353   {return expr;}
1354 }
1355
1356 String ClassIdentifier():
1357 {
1358   String expr;
1359   Token token;
1360 }
1361 {
1362   token = <IDENTIFIER>
1363   {return token.image;}
1364 |
1365   expr = VariableDeclaratorId()
1366   {return expr;}
1367 }
1368
1369 String PrimarySuffix() :
1370 {
1371   String expr;
1372 }
1373 {
1374   expr = Arguments()
1375   {return expr;}
1376 |
1377   expr = VariableSuffix()
1378   {return expr;}
1379 }
1380
1381 String VariableSuffix() :
1382 {
1383   String expr = null;
1384 }
1385 {
1386   <CLASSACCESS> expr = VariableName()
1387   {return "->" + expr;}
1388
1389   <LBRACKET> [ expr = Expression() ]
1390   try {
1391     <RBRACKET>
1392   } catch (ParseException e) {
1393     errorMessage = "']' expected";
1394     errorLevel   = ERROR;
1395     throw e;
1396   }
1397   {
1398     if(expr == null) {
1399       return "[]";
1400     }
1401     return "[" + expr + "]";
1402   }
1403 }
1404
1405 String Literal() :
1406 {
1407   String expr;
1408   Token token;
1409 }
1410 {
1411   token = <INTEGER_LITERAL>
1412   {return token.image;}
1413 |
1414   token = <FLOATING_POINT_LITERAL>
1415   {return token.image;}
1416 |
1417   token = <STRING_LITERAL>
1418   {return token.image;}
1419 |
1420   expr = BooleanLiteral()
1421   {return expr;}
1422 |
1423   expr = NullLiteral()
1424   {return expr;}
1425 }
1426
1427 String BooleanLiteral() :
1428 {}
1429 {
1430   <TRUE>
1431   {return "true";}
1432 |
1433   <FALSE>
1434   {return "false";}
1435 }
1436
1437 String NullLiteral() :
1438 {}
1439 {
1440   <NULL>
1441   {return "null";}
1442 }
1443
1444 String Arguments() :
1445 {
1446 String expr = null;
1447 }
1448 {
1449   <LPAREN> [ expr = ArgumentList() ]
1450   try {
1451     <RPAREN>
1452   } catch (ParseException e) {
1453     errorMessage = "')' expected to close the argument list";
1454     errorLevel   = ERROR;
1455     throw e;
1456   }
1457   {
1458   if (expr == null) {
1459     return "()";
1460   }
1461   return "(" + expr + ")";
1462   }
1463 }
1464
1465 String ArgumentList() :
1466 {
1467 String expr;
1468 StringBuffer buff = new StringBuffer();
1469 }
1470 {
1471   expr = Expression()
1472   {buff.append(expr);}
1473   ( <COMMA>
1474       try {
1475         expr = Expression()
1476       } catch (ParseException e) {
1477         errorMessage = "expression expected after a comma in argument list";
1478         errorLevel   = ERROR;
1479         throw e;
1480       }
1481     {
1482       buff.append(",").append("expr");
1483     }
1484    )*
1485    {return buff.toString();}
1486 }
1487
1488 /*
1489  * Statement syntax follows.
1490  */
1491
1492 void Statement() :
1493 {}
1494 {
1495   LOOKAHEAD(2)
1496   Expression()
1497   try {
1498     (<SEMICOLON> | "?>")
1499   } catch (ParseException e) {
1500     errorMessage = "';' expected";
1501     errorLevel   = ERROR;
1502     throw e;
1503   }
1504 |
1505   LOOKAHEAD(2)
1506   LabeledStatement()
1507 |
1508   Block()
1509 |
1510   EmptyStatement()
1511 |
1512   StatementExpression()
1513   try {
1514     <SEMICOLON>
1515   } catch (ParseException e) {
1516     errorMessage = "';' expected after expression";
1517     errorLevel   = ERROR;
1518     throw e;
1519   }
1520 |
1521   SwitchStatement()
1522 |
1523   IfStatement()
1524 |
1525   WhileStatement()
1526 |
1527   DoStatement()
1528 |
1529   ForStatement()
1530 |
1531   BreakStatement()
1532 |
1533   ContinueStatement()
1534 |
1535   ReturnStatement()
1536 |
1537   EchoStatement()
1538 |
1539   [<AT>] IncludeStatement()
1540 |
1541   StaticStatement()
1542 |
1543   GlobalStatement()
1544 }
1545
1546 void IncludeStatement() :
1547 {
1548   String expr;
1549   int pos = jj_input_stream.bufpos;
1550 }
1551 {
1552   <REQUIRE>
1553   expr = Expression()
1554   {currentSegment.add(new PHPReqIncDeclaration(currentSegment, "require",pos,expr));}
1555   try {
1556     (<SEMICOLON> | "?>")
1557   } catch (ParseException e) {
1558     errorMessage = "';' expected";
1559     errorLevel   = ERROR;
1560     throw e;
1561   }
1562 |
1563   <REQUIRE_ONCE>
1564   expr = Expression()
1565   {currentSegment.add(new PHPReqIncDeclaration(currentSegment, "require_once",pos,expr));}
1566   try {
1567     (<SEMICOLON> | "?>")
1568   } catch (ParseException e) {
1569     errorMessage = "';' expected";
1570     errorLevel   = ERROR;
1571     throw e;
1572   }
1573 |
1574   <INCLUDE>
1575   expr = Expression()
1576   {currentSegment.add(new PHPReqIncDeclaration(currentSegment, "include",pos,expr));}
1577   try {
1578     (<SEMICOLON> | "?>")
1579   } catch (ParseException e) {
1580     errorMessage = "';' expected";
1581     errorLevel   = ERROR;
1582     throw e;
1583   }
1584 |
1585   <INCLUDE_ONCE>
1586   expr = Expression()
1587   {currentSegment.add(new PHPReqIncDeclaration(currentSegment, "include_once",pos,expr));}
1588   try {
1589     (<SEMICOLON> | "?>")
1590   } catch (ParseException e) {
1591     errorMessage = "';' expected";
1592     errorLevel   = ERROR;
1593     throw e;
1594   }
1595 }
1596
1597 String PrintExpression() :
1598 {
1599   StringBuffer buff = new StringBuffer("print ");
1600   String expr;
1601 }
1602 {
1603   <PRINT> expr = Expression()
1604   {
1605     buff.append(expr);
1606     return buff.toString();
1607   }
1608 }
1609
1610 void EchoStatement() :
1611 {}
1612 {
1613   <ECHO> Expression() (<COMMA> Expression())*
1614   try {
1615     (<SEMICOLON> | "?>")
1616   } catch (ParseException e) {
1617     errorMessage = "';' expected after 'echo' statement";
1618     errorLevel   = ERROR;
1619     throw e;
1620   }
1621 }
1622
1623 void GlobalStatement() :
1624 {}
1625 {
1626   <GLOBAL> VariableDeclaratorId() (<COMMA> VariableDeclaratorId())*
1627   try {
1628     (<SEMICOLON> | "?>")
1629   } catch (ParseException e) {
1630     errorMessage = "';' expected";
1631     errorLevel   = ERROR;
1632     throw e;
1633   }
1634 }
1635
1636 void StaticStatement() :
1637 {}
1638 {
1639   <STATIC> VariableDeclarator() (<COMMA> VariableDeclarator())*
1640   try {
1641     (<SEMICOLON> | "?>")
1642   } catch (ParseException e) {
1643     errorMessage = "';' expected";
1644     errorLevel   = ERROR;
1645     throw e;
1646   }
1647 }
1648
1649 void LabeledStatement() :
1650 {}
1651 {
1652   <IDENTIFIER> <COLON> Statement()
1653 }
1654
1655 void Block() :
1656 {}
1657 {
1658   try {
1659     <LBRACE>
1660   } catch (ParseException e) {
1661     errorMessage = "'{' expected";
1662     errorLevel   = ERROR;
1663     throw e;
1664   }
1665   ( BlockStatement() )*
1666   <RBRACE>
1667 }
1668
1669 void BlockStatement() :
1670 {}
1671 {
1672   Statement()
1673 |
1674   ClassDeclaration()
1675 |
1676   MethodDeclaration()
1677 }
1678
1679 void LocalVariableDeclaration() :
1680 {}
1681 {
1682   VariableDeclarator() ( <COMMA> VariableDeclarator() )*
1683 }
1684
1685 void EmptyStatement() :
1686 {}
1687 {
1688   <SEMICOLON>
1689 }
1690
1691 void StatementExpression() :
1692 {}
1693 {
1694   PreIncrementExpression()
1695 |
1696   PreDecrementExpression()
1697 |
1698   PrimaryExpression()
1699   [
1700    <INCR>
1701   |
1702     <DECR>
1703   |
1704     AssignmentOperator() Expression()
1705   ]
1706 }
1707
1708 void SwitchStatement() :
1709 {}
1710 {
1711   <SWITCH> <LPAREN> Expression() <RPAREN> <LBRACE>
1712     ( SwitchLabel() ( BlockStatement() )* )*
1713   <RBRACE>
1714 }
1715
1716 void SwitchLabel() :
1717 {}
1718 {
1719   <CASE> Expression() <COLON>
1720 |
1721   <_DEFAULT> <COLON>
1722 }
1723
1724 void IfStatement() :
1725 /*
1726  * The disambiguating algorithm of JavaCC automatically binds dangling
1727  * else's to the innermost if statement.  The LOOKAHEAD specification
1728  * is to tell JavaCC that we know what we are doing.
1729  */
1730 {}
1731 {
1732   <IF> Condition("if") Statement() ( LOOKAHEAD(1) ElseIfStatement() )* [ LOOKAHEAD(1) <ELSE> Statement() ]
1733 }
1734
1735 void Condition(String keyword) :
1736 {}
1737 {
1738   try {
1739     <LPAREN>
1740   } catch (ParseException e) {
1741     errorMessage = "'(' expected after " + keyword + " keyword";
1742     errorLevel   = ERROR;
1743     throw e;
1744   }
1745   Expression()
1746   try {
1747      <RPAREN>
1748   } catch (ParseException e) {
1749     errorMessage = "')' expected after " + keyword + " keyword";
1750     errorLevel   = ERROR;
1751     throw e;
1752   }
1753 }
1754
1755 void ElseIfStatement() :
1756 {}
1757 {
1758   <ELSEIF> Condition("elseif") Statement()
1759 }
1760
1761 void WhileStatement() :
1762 {}
1763 {
1764   <WHILE> Condition("while") WhileStatement0()
1765 }
1766
1767 void WhileStatement0() :
1768 {}
1769 {
1770   <COLON> (Statement())* <ENDWHILE>
1771   try {
1772     (<SEMICOLON> | "?>")
1773   } catch (ParseException e) {
1774     errorMessage = "';' expected";
1775     errorLevel   = ERROR;
1776     throw e;
1777   }
1778 |
1779   Statement()
1780 }
1781
1782 void DoStatement() :
1783 {}
1784 {
1785   <DO> Statement() <WHILE> Condition("while")
1786   try {
1787     (<SEMICOLON> | "?>")
1788   } catch (ParseException e) {
1789     errorMessage = "';' expected";
1790     errorLevel   = ERROR;
1791     throw e;
1792   }
1793 }
1794
1795 void ForStatement() :
1796 {}
1797 {
1798   <FOR> <LPAREN> [ ForInit() ] <SEMICOLON> [ Expression() ] <SEMICOLON> [ ForUpdate() ] <RPAREN> Statement()
1799 }
1800
1801 void ForInit() :
1802 {}
1803 {
1804   LOOKAHEAD(LocalVariableDeclaration())
1805   LocalVariableDeclaration()
1806 |
1807   StatementExpressionList()
1808 }
1809
1810 void StatementExpressionList() :
1811 {}
1812 {
1813   StatementExpression() ( <COMMA> StatementExpression() )*
1814 }
1815
1816 void ForUpdate() :
1817 {}
1818 {
1819   StatementExpressionList()
1820 }
1821
1822 void BreakStatement() :
1823 {}
1824 {
1825   <BREAK> [ <IDENTIFIER> ] <SEMICOLON>
1826 }
1827
1828 void ContinueStatement() :
1829 {}
1830 {
1831   <CONTINUE> [ <IDENTIFIER> ] <SEMICOLON>
1832 }
1833
1834 void ReturnStatement() :
1835 {}
1836 {
1837   <RETURN> [ Expression() ] <SEMICOLON>
1838 }