*** empty log message ***
[phpeclipse.git] / net.sourceforge.phpeclipse / src / test / PHPParser2.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   ERROR_REPORTING = true;
10   JAVA_UNICODE_ESCAPE = false;
11   UNICODE_INPUT = false;
12   IGNORE_CASE = false;
13   USER_TOKEN_MANAGER = false;
14   USER_CHAR_STREAM = false;
15   BUILD_PARSER = true;
16   BUILD_TOKEN_MANAGER = true;
17   SANITY_CHECK = true;
18   FORCE_LA_CHECK = false;
19 }
20
21 PARSER_BEGIN(PHPParser2)
22 package test;
23
24 import org.eclipse.core.resources.IFile;
25 import org.eclipse.core.runtime.CoreException;
26
27 /**
28  * A new php parser.
29  * This php parser is inspired by the Java 1.2 grammar example 
30  * given with JavaCC. You can get JavaCC at http://www.webgain.com
31  * You can test the parser with the PHPParserTestCase2.java
32  * @author Matthieu Casanova
33  */
34 public class PHPParser2 {
35   
36   public PHPParser2(IFile fileToParse) throws CoreException {
37           this(fileToParse.getContents());
38   }
39   
40   public void parse() throws ParseException {
41           phpFile();
42   }
43   public static void main(String args[]) throws ParseException {
44     PHPParser2 parser = new PHPParser2(System.in);
45   }
46
47 }
48
49 PARSER_END(PHPParser2)
50
51
52 /* WHITE SPACE */
53
54 SKIP :
55 {
56   " "
57 | "\t"
58 | "\n"
59 | "\r"
60 | "\f"
61 }
62
63 /* COMMENTS */
64
65 MORE :
66 {
67   "//" : IN_SINGLE_LINE_COMMENT
68 |
69   <"/**" ~["/"]> { input_stream.backup(1); } : IN_FORMAL_COMMENT
70 |
71   "/*" : IN_MULTI_LINE_COMMENT
72 }
73
74 <IN_SINGLE_LINE_COMMENT>
75 SPECIAL_TOKEN :
76 {
77   <SINGLE_LINE_COMMENT: "\n" | "\r" | "\r\n" > : DEFAULT
78 }
79
80 <IN_FORMAL_COMMENT>
81 SPECIAL_TOKEN :
82 {
83   <FORMAL_COMMENT: "*/" > : DEFAULT
84 }
85
86 <IN_MULTI_LINE_COMMENT>
87 SPECIAL_TOKEN :
88 {
89   <MULTI_LINE_COMMENT: "*/" > : DEFAULT
90 }
91
92 <IN_SINGLE_LINE_COMMENT,IN_FORMAL_COMMENT,IN_MULTI_LINE_COMMENT>
93 MORE :
94 {
95   < ~[] >
96 }
97
98 /* KEYWORDS */
99 TOKEN :
100 {
101   <CLASS : "class">
102 | <FUNCTION : "function">
103 | <VAR      : "var">
104 | <IF       : "if">
105 | <ELSEIF   : "elseif">
106 | <ELSE     : "else">
107 | <ARRAY    : "array">
108 }
109
110 /* LANGUAGE CONSTRUCT */
111 TOKEN :
112 {
113   <ECHO : "echo">
114 | <GLOBAL : "global">
115 | <STATIC : "static">
116 }
117
118 /* RESERVED WORDS AND LITERALS */
119
120 TOKEN :
121 {
122   < BREAK: "break" >
123 | < CASE: "case" >
124 | < CONST: "const" >
125 | < CONTINUE: "continue" >
126 | < _DEFAULT: "default" >
127 | < DO: "do" >
128 | < EXTENDS: "extends" >
129 | < FALSE: "false" >
130 | < FOR: "for" >
131 | < GOTO: "goto" >
132 | < NEW: "new" >
133 | < NULL: "null" >
134 | < RETURN: "return" >
135 | < SUPER: "super" >
136 | < SWITCH: "switch" >
137 | < THIS: "this" >
138 | < TRUE: "true" >
139 | < WHILE: "while" >
140 }
141
142 /* TYPES */
143
144 TOKEN :
145 {
146   <STRING : "string">
147 | <OBJECT : "object">
148 | <BOOL : "bool">
149 | <BOOLEAN : "boolean">
150 | <REAL : "real">
151 | <DOUBLE : "double">
152 | <FLOAT : "float">
153 | <INT : "int">
154 | <INTEGER : "integer">
155 }
156
157 TOKEN :
158 {
159   < _ORL: "OR" >
160 | < _ANDL: "AND" >
161 }
162
163 /* LITERALS */
164
165 TOKEN :
166 {
167   < INTEGER_LITERAL:
168         <DECIMAL_LITERAL> (["l","L"])?
169       | <HEX_LITERAL> (["l","L"])?
170       | <OCTAL_LITERAL> (["l","L"])?
171   >
172 |
173   < #DECIMAL_LITERAL: ["1"-"9"] (["0"-"9"])* >
174 |
175   < #HEX_LITERAL: "0" ["x","X"] (["0"-"9","a"-"f","A"-"F"])+ >
176 |
177   < #OCTAL_LITERAL: "0" (["0"-"7"])* >
178 |
179   < FLOATING_POINT_LITERAL:
180         (["0"-"9"])+ "." (["0"-"9"])* (<EXPONENT>)? (["f","F","d","D"])?
181       | "." (["0"-"9"])+ (<EXPONENT>)? (["f","F","d","D"])?
182       | (["0"-"9"])+ <EXPONENT> (["f","F","d","D"])?
183       | (["0"-"9"])+ (<EXPONENT>)? ["f","F","d","D"]
184   >
185 |
186   < #EXPONENT: ["e","E"] (["+","-"])? (["0"-"9"])+ >
187 |
188   < STRING_LITERAL: (<STRING_1> | <STRING_2> | <STRING_3>)>
189 |    < STRING_1:
190       "\""
191       (   (~["\"","\\","\n","\r"])
192         | ("\\"
193             ( ["n","t","b","r","f","\\","'","\""]
194             | ["0"-"7"] ( ["0"-"7"] )?
195             | ["0"-"3"] ["0"-"7"] ["0"-"7"]
196             )
197           )
198       )*
199       "\""
200     >
201 |    < STRING_2:
202       "'"
203       (   (~["\"","\\","\n","\r"])
204         | ("\\"
205             ( ["n","t","b","r","f","\\","'","\""]
206             | ["0"-"7"] ( ["0"-"7"] )?
207             | ["0"-"3"] ["0"-"7"] ["0"-"7"]
208             )
209           )
210       )*
211       "'"
212     >
213 |   < STRING_3:
214       "`"
215       (   (~["\"","\\","\n","\r"])
216         | ("\\"
217             ( ["n","t","b","r","f","\\","'","\""]
218             | ["0"-"7"] ( ["0"-"7"] )?
219             | ["0"-"3"] ["0"-"7"] ["0"-"7"]
220             )
221           )
222       )*
223       ""
224     >
225 }
226
227 /* IDENTIFIERS */
228
229 TOKEN :
230 {
231   < IDENTIFIER: (<LETTER>|<SPECIAL>) (<LETTER>|<DIGIT>|<SPECIAL>)* >
232 |
233   < #LETTER:
234       ["a"-"z"] | ["A"-"Z"]
235   >
236 |
237   < #DIGIT:
238       ["0"-"9"]
239   >
240 |
241   < #SPECIAL:
242     "_"
243   >
244 }
245
246 /* SEPARATORS */
247
248 TOKEN :
249 {
250   < LPAREN: "(" >
251 | < RPAREN: ")" >
252 | < LBRACE: "{" >
253 | < RBRACE: "}" >
254 | < LBRACKET: "[" >
255 | < RBRACKET: "]" >
256 | < SEMICOLON: ";" >
257 | < COMMA: "," >
258 | < DOT: "." >
259 }
260
261 /* OPERATORS */
262
263 TOKEN :
264 {
265   < ASSIGN: "=" >
266 | < GT: ">" >
267 | < LT: "<" >
268 | < BANG: "!" >
269 | < TILDE: "~" >
270 | < HOOK: "?" >
271 | < COLON: ":" >
272 | < EQ: "==" >
273 | < LE: "<=" >
274 | < GE: ">=" >
275 | < NE: "!=" >
276 | < SC_OR: "||" >
277 | < SC_AND: "&&" >
278 | < INCR: "++" >
279 | < DECR: "--" >
280 | < PLUS: "+" >
281 | < MINUS: "-" >
282 | < STAR: "*" >
283 | < SLASH: "/" >
284 | < BIT_AND: "&" >
285 | < BIT_OR: "|" >
286 | < XOR: "^" >
287 | < REM: "%" >
288 | < LSHIFT: "<<" >
289 | < RSIGNEDSHIFT: ">>" >
290 | < RUNSIGNEDSHIFT: ">>>" >
291 | < PLUSASSIGN: "+=" >
292 | < MINUSASSIGN: "-=" >
293 | < STARASSIGN: "*=" >
294 | < SLASHASSIGN: "/=" >
295 | < ANDASSIGN: "&=" >
296 | < ORASSIGN: "|=" >
297 | < XORASSIGN: "^=" >
298 | < REMASSIGN: "%=" >
299 | < LSHIFTASSIGN: "<<=" >
300 | < RSIGNEDSHIFTASSIGN: ">>=" >
301 | < RUNSIGNEDSHIFTASSIGN: ">>>=" >
302 }
303
304
305 /*****************************************
306  * THE JAVA LANGUAGE GRAMMAR STARTS HERE *
307  *****************************************/
308
309 /*
310  * Program structuring syntax follows.
311  */
312
313 void phpFile() :
314 {}
315 {
316   (BlockStatement())*
317   <EOF>
318 }
319
320 void ClassDeclaration() :
321 {}
322 {
323   "class" <IDENTIFIER> [ "extends" <IDENTIFIER> ]
324   ClassBody()
325 }
326
327 void ClassBody() :
328 {}
329 {
330   "{" ( ClassBodyDeclaration() )* "}"
331 }
332
333 void ClassBodyDeclaration() :
334 {}
335 {
336   MethodDeclaration()
337 |
338   FieldDeclaration()
339 }
340
341 void FieldDeclaration() :
342 {}
343 {
344   "var" VariableDeclarator() ( "," VariableDeclarator() )* ";"
345 }
346
347 void VariableDeclarator() :
348 {}
349 {
350   VariableDeclaratorId() [ "=" VariableInitializer() ]
351 }
352
353 void VariableDeclaratorId() :
354 {}
355 {
356   "$" VariableName() ( LOOKAHEAD(2) VariableSuffix() )*
357 }
358
359 void VariableName():
360 {}
361 {
362   "this"
363 |
364   <IDENTIFIER>
365 |
366   "$" VariableName()
367 }
368
369 void VariableInitializer() :
370 {}
371 {
372   Expression()
373 }
374
375 void ArrayVariable() :
376 {}
377 {
378   Expression() ("=>" Expression())*
379 }
380
381 void ArrayInitializer() :
382 {}
383 {
384   "(" [ ArrayVariable() ( LOOKAHEAD(2) "," ArrayVariable() )* ] [ "," ] ")"
385 }
386
387 void MethodDeclaration() :
388 {}
389 {
390   "function" MethodDeclarator()
391   ( Block() | ";" )
392 }
393
394 void MethodDeclarator() :
395 {}
396 {
397   ["&"] <IDENTIFIER> FormalParameters()
398 }
399
400 void FormalParameters() :
401 {}
402 {
403   "(" [ FormalParameter() ( "," FormalParameter() )* ] ")"
404 }
405
406 void FormalParameter() :
407 {}
408 {
409   ["&"] VariableDeclarator()
410 }
411
412 void Type() :
413 {}
414 {
415   "string"
416 |
417   "bool"
418 |
419   "boolean"
420 |
421   "real"
422 |
423   "double"
424 |
425   "float"
426 |
427   "int"
428 |
429   "integer"
430 }
431
432 /*
433  * Expression syntax follows.
434  */
435
436 void Expression() :
437 /*
438  * This expansion has been written this way instead of:
439  *   Assignment() | ConditionalExpression()
440  * for performance reasons.
441  * However, it is a weakening of the grammar for it allows the LHS of
442  * assignments to be any conditional expression whereas it can only be
443  * a primary expression.  Consider adding a semantic predicate to work
444  * around this.
445  */
446 {}
447 {
448   ConditionalExpression()
449   [
450     AssignmentOperator() Expression()
451   ]
452 }
453
454 void AssignmentOperator() :
455 {}
456 {
457   "=" | "*=" | "/=" | "%=" | "+=" | "-=" | "<<=" | ">>=" | ">>>=" | "&=" | "^=" | "|=" | ".="
458 }
459
460 void ConditionalExpression() :
461 {}
462 {
463   ConditionalOrExpression() [ "?" Expression() ":" ConditionalExpression() ]
464 }
465
466 void ConditionalOrExpression() :
467 {}
468 {
469   ConditionalAndExpression() ( ("||" | "OR") ConditionalAndExpression() )*
470 }
471
472 void ConditionalAndExpression() :
473 {}
474 {
475   ConcatExpression() ( ("&&" | "AND") ConcatExpression() )*
476 }
477
478 void ConcatExpression() :
479 {}
480 {
481   InclusiveOrExpression() ( "." InclusiveOrExpression() )*
482 }
483
484 void InclusiveOrExpression() :
485 {}
486 {
487   ExclusiveOrExpression() ( "|" ExclusiveOrExpression() )*
488 }
489
490 void ExclusiveOrExpression() :
491 {}
492 {
493   AndExpression() ( "^" AndExpression() )*
494 }
495
496 void AndExpression() :
497 {}
498 {
499   EqualityExpression() ( "&" EqualityExpression() )*
500 }
501
502 void EqualityExpression() :
503 {}
504 {
505   RelationalExpression() ( ( "==" | "!=" ) RelationalExpression() )*
506 }
507
508 void RelationalExpression() :
509 {}
510 {
511   ShiftExpression() ( ( "<" | ">" | "<=" | ">=" ) ShiftExpression() )*
512 }
513
514 void ShiftExpression() :
515 {}
516 {
517   AdditiveExpression() ( ( "<<" | ">>" | ">>>" ) AdditiveExpression() )*
518 }
519
520 void AdditiveExpression() :
521 {}
522 {
523   MultiplicativeExpression() ( ( "+" | "-" ) MultiplicativeExpression() )*
524 }
525
526 void MultiplicativeExpression() :
527 {}
528 {
529   UnaryExpression() ( ( "*" | "/" | "%" ) UnaryExpression() )*
530 }
531
532 void UnaryExpression() :
533 {}
534 {
535   "@" UnaryExpression()
536 |
537   ( "+" | "-" ) UnaryExpression()
538 |
539   PreIncrementExpression()
540 |
541   PreDecrementExpression()
542 |
543   UnaryExpressionNotPlusMinus()
544 }
545
546 void PreIncrementExpression() :
547 {}
548 {
549   "++" PrimaryExpression()
550 }
551
552 void PreDecrementExpression() :
553 {}
554 {
555   "--" PrimaryExpression()
556 }
557
558 void UnaryExpressionNotPlusMinus() :
559 {}
560 {
561   ( "~" | "!" ) UnaryExpression()
562 |
563   LOOKAHEAD( "(" Type() ")" )
564   CastExpression()
565 |
566   PostfixExpression()
567 |
568   Literal()
569 |
570   "("Expression()")"
571 }
572
573 void CastExpression() :
574 {}
575 {
576   "(" Type() ")" UnaryExpression()
577 }
578
579 void PostfixExpression() :
580 {}
581 {
582   PrimaryExpression() [ "++" | "--" ]
583 }
584
585 void PrimaryExpression() :
586 {}
587 {
588   LOOKAHEAD(2)
589   <IDENTIFIER> "::" ClassIdentifier() (PrimarySuffix())*
590 |
591   PrimaryPrefix() ( PrimarySuffix() )*
592 |
593   "array" ArrayInitializer()
594 }
595
596 void PrimaryPrefix() :
597 {}
598 {
599   "$this"
600 |
601   <IDENTIFIER>
602 |
603   "new" ClassIdentifier()
604 |  
605   VariableDeclaratorId()
606 }
607
608 void ClassIdentifier():
609 {}
610 {
611   <IDENTIFIER>
612 |
613   VariableDeclaratorId()
614 |
615   "$this"
616 }
617
618 void PrimarySuffix() :
619 {}
620 {
621   Arguments()
622 |
623   VariableSuffix()
624 }
625
626 void VariableSuffix() :
627 {}
628 {
629   "->" VariableName()
630
631   "[" Expression() "]"
632 }
633
634 void Literal() :
635 {}
636 {
637   <INTEGER_LITERAL>
638 |
639   <FLOATING_POINT_LITERAL>
640 |
641   <STRING_LITERAL>
642 |
643   BooleanLiteral()
644 |
645   NullLiteral()
646 }
647
648 void BooleanLiteral() :
649 {}
650 {
651   "true"
652 |
653   "false"
654 }
655
656 void NullLiteral() :
657 {}
658 {
659   "null"
660 }
661
662 void Arguments() :
663 {}
664 {
665   "(" [ ArgumentList() ] ")"
666 }
667
668 void ArgumentList() :
669 {}
670 {
671   Expression() ( "," Expression() )*
672 }
673
674 /*
675  * Statement syntax follows.
676  */
677
678 void Statement() :
679 {}
680 {
681   LOOKAHEAD(2)
682   LabeledStatement()
683 |
684   LOOKAHEAD(2)
685   Expression() ";"
686 |
687   Block()
688 |
689   EmptyStatement()
690 |
691   StatementExpression() ";"
692 |
693   SwitchStatement()
694 |
695   IfStatement()
696 |
697   WhileStatement()
698 |
699   DoStatement()
700 |
701   ForStatement()
702 |
703   BreakStatement()
704 |
705   ContinueStatement()
706 |
707   ReturnStatement()
708 |
709   EchoStatement()
710 |
711   StaticStatement()
712 }
713
714 void EchoStatement() :
715 {}
716 {
717   "echo" Expression() ("," Expression())* ";"
718 }
719
720 void GlobalStatement() :
721 {}
722 {
723   "global" VariableDeclaratorId() ("," VariableDeclaratorId())* ";"
724 }
725
726 void StaticStatement() :
727 {}
728 {
729   "static" VariableDeclarator() ("," VariableDeclarator())* ";"
730 }
731
732 void LabeledStatement() :
733 {}
734 {
735   <IDENTIFIER> ":" Statement()
736 }
737
738 void Block() :
739 {}
740 {
741   "{" ( BlockStatement() )* "}"
742 }
743
744 void BlockStatement() :
745 {}
746 {
747   Statement()
748 |
749   ClassDeclaration()
750 |
751   MethodDeclaration()
752 }
753
754 void LocalVariableDeclaration() :
755 {}
756 {
757   VariableDeclarator() ( "," VariableDeclarator() )*
758 }
759
760 void EmptyStatement() :
761 {}
762 {
763   ";"
764 }
765
766 void StatementExpression() :
767 /*
768  * The last expansion of this production accepts more than the legal
769  * Java expansions for StatementExpression.  This expansion does not
770  * use PostfixExpression for performance reasons.
771  */
772 {}
773 {
774   PreIncrementExpression()
775 |
776   PreDecrementExpression()
777 |
778   PrimaryExpression()
779   [
780     "++"
781   |
782     "--"
783   |
784     AssignmentOperator() Expression()
785   ]
786 }
787
788 void SwitchStatement() :
789 {}
790 {
791   "switch" "(" Expression() ")" "{"
792     ( SwitchLabel() ( BlockStatement() )* )*
793   "}"
794 }
795
796 void SwitchLabel() :
797 {}
798 {
799   "case" Expression() ":"
800 |
801   "default" ":"
802 }
803
804 void IfStatement() :
805 /*
806  * The disambiguating algorithm of JavaCC automatically binds dangling
807  * else's to the innermost if statement.  The LOOKAHEAD specification
808  * is to tell JavaCC that we know what we are doing.
809  */
810 {}
811 {
812   "if" "(" Expression() ")" Statement() [ LOOKAHEAD(1) ElseIfStatement() ] [ LOOKAHEAD(1) "else" Statement() ]
813 }
814
815 void ElseIfStatement() :
816 {}
817 {
818   "elseif" "(" Expression() ")" Statement()
819 }
820
821 void WhileStatement() :
822 {}
823 {
824   "while" "(" Expression() ")" Statement()
825 }
826
827 void DoStatement() :
828 {}
829 {
830   "do" Statement() "while" "(" Expression() ")" ";"
831 }
832
833 void ForStatement() :
834 {}
835 {
836   "for" "(" [ ForInit() ] ";" [ Expression() ] ";" [ ForUpdate() ] ")" Statement()
837 }
838
839 void ForInit() :
840 {}
841 {
842   LOOKAHEAD(LocalVariableDeclaration())
843   LocalVariableDeclaration()
844 |
845   StatementExpressionList()
846 }
847
848 void StatementExpressionList() :
849 {}
850 {
851   StatementExpression() ( "," StatementExpression() )*
852 }
853
854 void ForUpdate() :
855 {}
856 {
857   StatementExpressionList()
858 }
859
860 void BreakStatement() :
861 {}
862 {
863   "break" [ <IDENTIFIER> ] ";"
864 }
865
866 void ContinueStatement() :
867 {}
868 {
869   "continue" [ <IDENTIFIER> ] ";"
870 }
871
872 void ReturnStatement() :
873 {}
874 {
875   "return" [ Expression() ] ";"
876 }