1 %{
2 /*
3 * If you modify this grammar, please update the version number in
4 * ./xhpast.cpp and libphutil/src/parser/xhpast/bin/xhpast_parse.php
5 */
6
7 #include "ast.hpp"
8 #include "node_names.hpp"
9 // PHP's if/else rules use right reduction rather than left reduction which
10 // means while parsing nested if/else's the stack grows until it the last
11 // statement is read. This is annoying, particularly because of a quirk in
12 // bison.
13 // http://www.gnu.org/software/bison/manual/html_node/Memory-Management.html
14 // Apparently if you compile a bison parser with g++ it can no longer grow
15 // the stack. The work around is to just make your initial stack ridiculously
16 // large. Unfortunately that increases memory usage while parsing which is
17 // dumb. Anyway, putting a TODO here to fix PHP's if/else grammar.
18 #define YYINITDEPTH 500
19 %}
20
21 %{
22 #undef yyextra
23 #define yyextra static_cast<yy_extra_type*>(xhpastget_extra(yyscanner))
24 #undef yylineno
25 #define yylineno yyextra->first_lineno
26 #define push_state(s) xhp_new_push_state(s, (struct yyguts_t*) yyscanner)
27 #define pop_state() xhp_new_pop_state((struct yyguts_t*) yyscanner)
28 #define set_state(s) xhp_set_state(s, (struct yyguts_t*) yyscanner)
29
30 #define NNEW(t) \
31 (new xhpast::Node(t))
32
33 #define NTYPE(n, type) \
34 ((n)->setType(type))
35
36 #define NMORE(n, end) \
37 ((n)->expandRange(end))
38
39 #define NSPAN(n, type, end) \
40 (NMORE(NTYPE((n), type), end))
41
42 #define NEXPAND(l, n, r) \
43 ((n)->expandRange(l)->expandRange(r))
44
45 using namespace std;
46
yyerror(void * yyscanner,void * _,const char * error)47 static void yyerror(void* yyscanner, void* _, const char* error) {
48 if (yyextra->terminated) {
49 return;
50 }
51 yyextra->terminated = true;
52 yyextra->error = error;
53 }
54
55 %}
56
57 %expect 5
58 // 2: PHP's if/else grammar
59 // 7: expr '[' dim_offset ']' -- shift will default to first grammar
60 %pure-parser
61 %parse-param { void* yyscanner }
62 %parse-param { xhpast::Node** root }
63 %lex-param { void* yyscanner }
64 %error-verbose
65
66 %left T_INCLUDE T_INCLUDE_ONCE T_EVAL T_REQUIRE T_REQUIRE_ONCE
67 %left ','
68 %left T_LOGICAL_OR
69 %left T_LOGICAL_XOR
70 %left T_LOGICAL_AND
71 %right T_PRINT
72 %left '=' T_PLUS_EQUAL
73 T_MINUS_EQUAL
74 T_MUL_EQUAL
75 T_DIV_EQUAL
76 T_CONCAT_EQUAL
77 T_MOD_EQUAL
78 T_AND_EQUAL
79 T_OR_EQUAL
80 T_XOR_EQUAL
81 T_SL_EQUAL
82 T_SR_EQUAL
83 %left '?' ':'
84 %right T_COALESCE
85 %left T_BOOLEAN_OR
86 %left T_BOOLEAN_AND
87 %left '|'
88 %left '^'
89 %left '&'
90 %nonassoc T_IS_EQUAL T_IS_NOT_EQUAL T_IS_IDENTICAL T_IS_NOT_IDENTICAL
91 T_SPACESHIP
92 %nonassoc '<' T_IS_SMALLER_OR_EQUAL '>' T_IS_GREATER_OR_EQUAL
93 %left T_SL T_SR
94 %left '+' '-' '.'
95 %left '*' '/' '%'
96 %right '!'
97 %nonassoc T_INSTANCEOF
98 %right '~' T_INC
99 T_DEC
100 T_INT_CAST
101 T_DOUBLE_CAST
102 T_STRING_CAST
103 T_UNICODE_CAST
104 T_BINARY_CAST
105 T_ARRAY_CAST
106 T_OBJECT_CAST
107 T_BOOL_CAST
108 T_UNSET_CAST
109 '@'
110 %right '['
111 %nonassoc T_NEW T_CLONE
112 %token T_EXIT
113 %token T_IF
114 %left T_ELSEIF
115 %left T_ELSE
116 %left T_ENDIF
117
118 %token T_LNUMBER
119 %token T_DNUMBER
120 %token T_STRING
121 %token T_STRING_VARNAME /* unused in XHP: `foo` in `"$foo"` */
122 %token T_VARIABLE
123 %token T_NUM_STRING /* unused in XHP: `0` in `"$foo[0]"` */
124 %token T_INLINE_HTML
125 %token T_CHARACTER /* unused in vanilla PHP */
126 %token T_BAD_CHARACTER /* unused in vanilla PHP */
127 %token T_ENCAPSED_AND_WHITESPACE /* unused in XHP: ` ` in `" "` */
128 %token T_CONSTANT_ENCAPSED_STRING /* overloaded in XHP;
129 replaces '"' encaps_list '"' */
130 %token T_BACKTICKS_EXPR /* new in XHP; replaces '`' backticks_expr '`' */
131 %token T_ECHO
132 %token T_DO
133 %token T_WHILE
134 %token T_ENDWHILE
135 %token T_FOR
136 %token T_ENDFOR
137 %token T_FOREACH
138 %token T_ENDFOREACH
139 %token T_DECLARE
140 %token T_ENDDECLARE
141 %token T_AS
142 %token T_SWITCH
143 %token T_ENDSWITCH
144 %token T_CASE
145 %token T_DEFAULT
146 %token T_BREAK
147 %token T_CONTINUE
148 %token T_GOTO
149 %token T_FUNCTION
150 %token T_CONST
151 %token T_RETURN
152 %token T_TRY
153 %token T_CATCH
154 %token T_THROW
155 %token T_USE
156 %token T_GLOBAL
157 %right T_STATIC T_ABSTRACT T_FINAL T_PRIVATE T_PROTECTED T_PUBLIC
158 %token T_VAR
159 %token T_UNSET
160 %token T_ISSET
161 %token T_EMPTY
162 %token T_HALT_COMPILER
163 %token T_CLASS
164 %token T_INTERFACE
165 %token T_EXTENDS
166 %token T_IMPLEMENTS
167 %token T_OBJECT_OPERATOR
168 %token T_DOUBLE_ARROW
169 %token T_LIST
170 %token T_ARRAY
171 %token T_CLASS_C
172 %token T_METHOD_C
173 %token T_FUNC_C
174 %token T_LINE
175 %token T_FILE
176 %token T_COMMENT
177 %token T_DOC_COMMENT
178 %token T_OPEN_TAG
179 %token T_OPEN_TAG_WITH_ECHO
180 %token T_OPEN_TAG_FAKE
181 %token T_CLOSE_TAG
182 %token T_WHITESPACE
183 %token T_START_HEREDOC /* unused in XHP; replaced with T_HEREDOC */
184 %token T_END_HEREDOC /* unused in XHP; replaced with T_HEREDOC */
185 %token T_HEREDOC /* new in XHP;
186 replaces start_heredoc encaps_list T_END_HEREDOC */
187 %token T_DOLLAR_OPEN_CURLY_BRACES /* unused in XHP: `${` in `"${foo}"` */
188 %token T_CURLY_OPEN /* unused in XHP: `{$` in `"{$foo}"` */
189 %token T_PAAMAYIM_NEKUDOTAYIM
190 %token T_BINARY_DOUBLE /* unsused in XHP: `b"` in `b"foo"` */
191 %token T_BINARY_HEREDOC /* unsused in XHP: `b<<<` in `b<<<FOO` */
192 %token T_NAMESPACE
193 %token T_NS_C
194 %token T_DIR
195 %token T_NS_SEPARATOR
196 %token T_INSTEADOF
197 %token T_CALLABLE
198 %token T_TRAIT
199 %token T_TRAIT_C
200 %token T_YIELD
201 %token T_FINALLY
202 %token T_ELLIPSIS
203
204 %%
205
206 start:
207 top_statement_list {
208 *root = NNEW(n_PROGRAM)->appendChild($1);
209 }
210 ;
211
212 top_statement_list:
213 top_statement_list top_statement {
214 $$ = $1->appendChild($2);
215 }
216 | /* empty */ {
217 $$ = NNEW(n_STATEMENT_LIST);
218 }
219 ;
220
221 namespace_name:
222 T_STRING {
223 $$ = NTYPE($1, n_SYMBOL_NAME);
224 }
225 | namespace_name T_NS_SEPARATOR T_STRING {
226 $$ = NMORE($1, $3);
227 }
228 ;
229
230 top_statement:
231 statement
232 | function_declaration_statement
233 | class_declaration_statement
234 | T_HALT_COMPILER '(' ')' ';' {
235 $1 = NSPAN($1, n_HALT_COMPILER, $3);
236 $$ = NNEW(n_STATEMENT)->appendChild($1);
237 NMORE($$, $4);
238 }
239 | T_NAMESPACE namespace_name ';' {
240 NSPAN($1, n_NAMESPACE, $2);
241 $1->appendChild($2);
242 $1->appendChild(NNEW(n_EMPTY));
243 $$ = NNEW(n_STATEMENT)->appendChild($1);
244 NMORE($$, $3);
245 }
246 | T_NAMESPACE namespace_name '{' top_statement_list '}' {
247 NSPAN($1, n_NAMESPACE, $5);
248 $1->appendChild($2);
249 $1->appendChild(NEXPAND($3, $4, $5));
250 $$ = NNEW(n_STATEMENT)->appendChild($1);
251 }
252 | T_NAMESPACE '{' top_statement_list '}' {
253 NSPAN($1, n_NAMESPACE, $4);
254 $1->appendChild(NNEW(n_EMPTY));
255 NMORE($3, $4);
256 NMORE($3, $2);
257 $1->appendChild($3);
258 $$ = NNEW(n_STATEMENT)->appendChild($1);
259 }
260 | T_USE use_declarations ';' {
261 NMORE($2, $1);
262 $$ = NNEW(n_STATEMENT)->appendChild($2);
263 NMORE($$, $3);
264 }
265 | constant_declaration ';' {
266 $$ = NNEW(n_STATEMENT)->appendChild($1);
267 NMORE($$, $2);
268 }
269 ;
270
271 use_declarations:
272 use_declarations ',' use_declaration {
273 $$ = $1->appendChild($3);
274 }
275 | use_declaration {
276 $$ = NNEW(n_USE_LIST);
277 $$->appendChild($1);
278 }
279 ;
280
281 use_declaration:
282 namespace_name {
283 $$ = NNEW(n_USE);
284 $$->appendChild($1);
285 $$->appendChild(NNEW(n_EMPTY));
286 }
287 | namespace_name T_AS T_STRING {
288 $$ = NNEW(n_USE);
289 $$->appendChild($1);
290 NTYPE($3, n_STRING);
291 $$->appendChild($3);
292 }
293 | T_NS_SEPARATOR namespace_name {
294 $$ = NNEW(n_USE);
295 NMORE($2, $1);
296 $$->appendChild($2);
297 $$->appendChild(NNEW(n_EMPTY));
298 }
299 | T_NS_SEPARATOR namespace_name T_AS T_STRING {
300 $$ = NNEW(n_USE);
301 NMORE($2, $1);
302 $$->appendChild($2);
303 NTYPE($4, n_STRING);
304 $$->appendChild($4);
305 }
306 ;
307
308 constant_declaration:
309 constant_declaration ',' T_STRING '=' static_scalar {
310 NMORE($$, $5);
311 $$->appendChild(
312 NNEW(n_CONSTANT_DECLARATION)
313 ->appendChild(NTYPE($3, n_STRING))
314 ->appendChild($5));
315 }
316 | T_CONST T_STRING '=' static_scalar {
317 NSPAN($$, n_CONSTANT_DECLARATION_LIST, $4);
318 $$->appendChild(
319 NNEW(n_CONSTANT_DECLARATION)
320 ->appendChild(NTYPE($2, n_STRING))
321 ->appendChild($4));
322 }
323 ;
324
325 inner_statement_list:
326 inner_statement_list inner_statement {
327 $$ = $1->appendChild($2);
328 }
329 | /* empty */ {
330 $$ = NNEW(n_STATEMENT_LIST);
331 }
332 ;
333
334 inner_statement:
335 statement
336 | function_declaration_statement
337 | class_declaration_statement
338 | T_HALT_COMPILER '(' ')' ';' {
339 $1 = NSPAN($1, n_HALT_COMPILER, $3);
340 $$ = NNEW(n_STATEMENT)->appendChild($1);
341 NMORE($$, $4);
342 }
343 ;
344
345 statement:
346 unticked_statement
347 | T_STRING ':' {
348 NTYPE($1, n_STRING);
349 $$ = NNEW(n_LABEL);
350 $$->appendChild($1);
351 NMORE($$, $2);
352 }
353 | T_OPEN_TAG {
354 $$ = NTYPE($1, n_OPEN_TAG);
355 }
356 | T_OPEN_TAG_WITH_ECHO {
357 $$ = NTYPE($1, n_OPEN_TAG);
358 }
359 | T_CLOSE_TAG {
360 $$ = NTYPE($1, n_CLOSE_TAG);
361 }
362 ;
363
364 unticked_statement:
365 '{' inner_statement_list '}' {
366 $$ = NEXPAND($1, $2, $3);
367 }
368 | T_IF '(' expr ')' statement elseif_list else_single {
369 $$ = NNEW(n_CONDITION_LIST);
370
371 $1 = NTYPE($1, n_IF);
372 $1->appendChild(NSPAN($2, n_CONTROL_CONDITION, $4)->appendChild($3));
373 $1->appendChild($5);
374
375 $$->appendChild($1);
376 $$->appendChildren($6);
377
378 // Hacks: merge a list of if (x) { } else if (y) { } into a single condition
379 // list instead of a condition tree.
380
381 if ($7->type == n_EMPTY) {
382 // Ignore.
383 } else if ($7->type == n_ELSE) {
384 xhpast::Node *stype = $7->firstChild()->firstChild();
385 if (stype && stype->type == n_CONDITION_LIST) {
386 NTYPE(stype->firstChild(), n_ELSEIF);
387 stype->firstChild()->l_tok = $7->l_tok;
388 $$->appendChildren(stype);
389 } else {
390 $$->appendChild($7);
391 }
392 } else {
393 $$->appendChild($7);
394 }
395
396 $$ = NNEW(n_STATEMENT)->appendChild($$);
397 }
398 | T_IF '(' expr ')' ':'
399 inner_statement_list
400 new_elseif_list
401 new_else_single
402 T_ENDIF ';' {
403
404 $$ = NNEW(n_CONDITION_LIST);
405 NTYPE($1, n_IF);
406 $1->appendChild(NSPAN($2, n_CONTROL_CONDITION, $4)->appendChild($3));
407 $1->appendChild($6);
408
409 $$->appendChild($1);
410 $$->appendChildren($7);
411 $$->appendChild($8);
412 NMORE($$, $9);
413
414 $$ = NNEW(n_STATEMENT)->appendChild($$);
415 NMORE($$, $10);
416 }
417 | T_WHILE '(' expr ')' while_statement {
418 NTYPE($1, n_WHILE);
419 $1->appendChild(NSPAN($2, n_CONTROL_CONDITION, $4)->appendChild($3));
420 $1->appendChild($5);
421
422 $$ = NNEW(n_STATEMENT)->appendChild($1);
423 }
424 | T_DO statement T_WHILE '(' expr ')' ';' {
425 NTYPE($1, n_DO_WHILE);
426 $1->appendChild($2);
427 $1->appendChild(NSPAN($4, n_CONTROL_CONDITION, $6)->appendChild($5));
428
429 $$ = NNEW(n_STATEMENT)->appendChild($1);
430 NMORE($$, $7);
431 }
432 | T_FOR '(' for_expr ';' for_expr ';' for_expr ')' for_statement {
433 NTYPE($1, n_FOR);
434
435 NSPAN($2, n_FOR_EXPRESSION, $8)
436 ->appendChild($3)
437 ->appendChild($5)
438 ->appendChild($7);
439
440 $1->appendChild($2);
441 $1->appendChild($9);
442
443 $$ = NNEW(n_STATEMENT)->appendChild($1);
444 }
445 | T_SWITCH '(' expr ')' switch_case_list {
446 NTYPE($1, n_SWITCH);
447 $1->appendChild(NSPAN($2, n_CONTROL_CONDITION, $4)->appendChild($3));
448 $1->appendChild($5);
449
450 $$ = NNEW(n_STATEMENT)->appendChild($1);
451 }
452 | T_BREAK ';' {
453 NTYPE($1, n_BREAK);
454 $1->appendChild(NNEW(n_EMPTY));
455
456 $$ = NNEW(n_STATEMENT)->appendChild($1);
457 NMORE($$, $2);
458 }
459 | T_BREAK expr ';' {
460 NTYPE($1, n_BREAK);
461 $1->appendChild($2);
462
463 $$ = NNEW(n_STATEMENT)->appendChild($1);
464 NMORE($$, $3);
465 }
466 | T_CONTINUE ';' {
467 NTYPE($1, n_CONTINUE);
468 $1->appendChild(NNEW(n_EMPTY));
469
470 $$ = NNEW(n_STATEMENT)->appendChild($1);
471 NMORE($$, $2);
472 }
473 | T_CONTINUE expr ';' {
474 NTYPE($1, n_CONTINUE);
475 $1->appendChild($2);
476
477 $$ = NNEW(n_STATEMENT)->appendChild($1);
478 NMORE($$, $3);
479 }
480 | T_RETURN ';' {
481 NTYPE($1, n_RETURN);
482 $1->appendChild(NNEW(n_EMPTY));
483
484 $$ = NNEW(n_STATEMENT)->appendChild($1);
485 NMORE($$, $2);
486 }
487 | T_RETURN expr_without_variable ';' {
488 NTYPE($1, n_RETURN);
489 $1->appendChild($2);
490
491 $$ = NNEW(n_STATEMENT)->appendChild($1);
492 NMORE($$, $3);
493 }
494 | T_RETURN variable ';' {
495 NTYPE($1, n_RETURN);
496 $1->appendChild($2);
497
498 $$ = NNEW(n_STATEMENT)->appendChild($1);
499 NMORE($$, $3);
500 }
501 | T_GLOBAL global_var_list ';' {
502 NMORE($2, $1);
503 $$ = NNEW(n_STATEMENT)->appendChild($2);
504 NMORE($$, $3);
505 }
506 | T_STATIC static_var_list ';' {
507 NMORE($2, $1);
508 $$ = NNEW(n_STATEMENT)->appendChild($2);
509 NMORE($$, $3);
510 }
511 | T_ECHO echo_expr_list ';' {
512 NMORE($2, $1);
513 $$ = NNEW(n_STATEMENT)->appendChild($2);
514 NMORE($$, $3);
515 }
516 | T_INLINE_HTML {
517 NTYPE($1, n_INLINE_HTML);
518 $$ = $1;
519 }
520 | expr ';' {
521 $$ = NNEW(n_STATEMENT)->appendChild($1);
522 NMORE($$, $2);
523 }
524 | yield_expr ';' {
525 $$ = NNEW(n_STATEMENT)->appendChild($1);
526 NMORE($$, $2);
527 }
528 | T_UNSET '(' unset_variables ')' ';' {
529 NMORE($3, $4);
530 NMORE($3, $1);
531 $$ = NNEW(n_STATEMENT)->appendChild($3);
532 NMORE($$, $5);
533 }
534 | T_FOREACH '(' variable T_AS foreach_variable foreach_optional_arg ')'
535 foreach_statement {
536 NTYPE($1, n_FOREACH);
537 NSPAN($2, n_FOREACH_EXPRESSION, $7);
538 $2->appendChild($3);
539 if ($6->type == n_EMPTY) {
540 $2->appendChild($6);
541 $2->appendChild($5);
542 } else {
543 $2->appendChild($5);
544 $2->appendChild($6);
545 }
546 $1->appendChild($2);
547
548 $1->appendChild($8);
549
550 $$ = NNEW(n_STATEMENT)->appendChild($1);
551 }
552 | T_FOREACH '(' expr_without_variable T_AS variable foreach_optional_arg ')'
553 foreach_statement {
554 NTYPE($1, n_FOREACH);
555 NSPAN($2, n_FOREACH_EXPRESSION, $7);
556 $2->appendChild($3);
557 if ($6->type == n_EMPTY) {
558 $2->appendChild($6);
559 $2->appendChild($5);
560 } else {
561 $2->appendChild($5);
562 $2->appendChild($6);
563 }
564 $1->appendChild($2);
565 $1->appendChild($8);
566
567 $$ = NNEW(n_STATEMENT)->appendChild($1);
568 }
569 | T_DECLARE '(' declare_list ')' declare_statement {
570 NTYPE($1, n_DECLARE);
571 $1->appendChild($3);
572 $1->appendChild($5);
573 $$ = NNEW(n_STATEMENT)->appendChild($1);
574 }
575 | ';' /* empty statement */ {
576 $$ = NNEW(n_STATEMENT)->appendChild(NNEW(n_EMPTY));
577 NMORE($$, $1);
578 }
579 | T_TRY '{' inner_statement_list '}' catch_list finally_statement {
580 NTYPE($1, n_TRY);
581 $1->appendChild(NEXPAND($2, $3, $4));
582
583 $1->appendChild($5);
584 $1->appendChild($6);
585
586 $$ = NNEW(n_STATEMENT)->appendChild($1);
587 }
588 | T_TRY '{' inner_statement_list '}' non_empty_finally_statement {
589 NTYPE($1, n_TRY);
590 $1->appendChild(NEXPAND($2, $3, $4));
591
592 $1->appendChild(NNEW(n_CATCH_LIST));
593 $1->appendChild($5);
594
595 $$ = NNEW(n_STATEMENT)->appendChild($1);
596 }
597 | T_THROW expr ';' {
598 NTYPE($1, n_THROW);
599 $1->appendChild($2);
600
601 $$ = NNEW(n_STATEMENT)->appendChild($1);
602 NMORE($$, $3);
603
604 }
605 | T_GOTO T_STRING ';' {
606 NTYPE($1, n_GOTO);
607 NTYPE($2, n_STRING);
608 $1->appendChild($2);
609
610 $$ = NNEW(n_STATEMENT)->appendChild($1);
611 NMORE($$, $3);
612 }
613 ;
614
615 catch_list:
616 catch_list catch {
617 $1->appendChild($2);
618 $$ = $1;
619 }
620 | catch {
621 $$ = NNEW(n_CATCH_LIST);
622 $$->appendChild($1);
623 }
624
625 catch:
626 T_CATCH '(' fully_qualified_class_name T_VARIABLE ')'
627 '{' inner_statement_list '}' {
628 NTYPE($1, n_CATCH);
629 $1->appendChild($3);
630 $1->appendChild(NTYPE($4, n_VARIABLE));
631 $1->appendChild(NEXPAND($6, $7, $8));
632 NMORE($1, $8);
633 $$ = $1;
634 }
635 ;
636
637 finally_statement:
638 /* empty */ {
639 $$ = NNEW(n_EMPTY);
640 }
641 | non_empty_finally_statement
642 ;
643
644 non_empty_finally_statement:
645 T_FINALLY '{' inner_statement_list '}' {
646 NTYPE($1, n_FINALLY);
647 $1->appendChild($3);
648 NMORE($1, $4);
649 $$ = $1;
650 }
651 ;
652
653 unset_variables:
654 unset_variable {
655 $$ = NNEW(n_UNSET_LIST);
656 $$->appendChild($1);
657 }
658 | unset_variables ',' unset_variable {
659 $1->appendChild($3);
660 $$ = $1;
661 }
662 ;
663
664 unset_variable:
665 variable
666 ;
667
668 function_declaration_statement:
669 unticked_function_declaration_statement
670 ;
671
672 class_declaration_statement:
673 unticked_class_declaration_statement
674 ;
675
676 is_reference:
677 /* empty */ {
678 $$ = NNEW(n_EMPTY);
679 }
680 | '&' {
681 $$ = NTYPE($1, n_REFERENCE);
682 }
683 ;
684
685 unticked_function_declaration_statement:
686 function is_reference T_STRING
687 '(' parameter_list ')' return_type '{' inner_statement_list '}' {
688 NSPAN($1, n_FUNCTION_DECLARATION, $9);
689 $1->appendChild(NNEW(n_EMPTY));
690 $1->appendChild($2);
691 $1->appendChild(NTYPE($3, n_STRING));
692 $1->appendChild(NEXPAND($4, $5, $6));
693 $1->appendChild(NNEW(n_EMPTY));
694 $1->appendChild($7);
695 $1->appendChild(NEXPAND($8, $9, $10));
696
697 $$ = NNEW(n_STATEMENT)->appendChild($1);
698 }
699 ;
700
701 unticked_class_declaration_statement:
702 class_entry_type T_STRING extends_from implements_list
703 '{' class_statement_list '}' {
704 $$ = NNEW(n_CLASS_DECLARATION);
705 $$->appendChild($1);
706 $$->appendChild(NTYPE($2, n_CLASS_NAME));
707 $$->appendChild($3);
708 $$->appendChild($4);
709 $$->appendChild(NEXPAND($5, $6, $7));
710 NMORE($$, $7);
711
712 $$ = NNEW(n_STATEMENT)->appendChild($$);
713 }
714 | interface_entry T_STRING interface_extends_list '{' class_statement_list '}' {
715 $$ = NNEW(n_INTERFACE_DECLARATION);
716 $$->appendChild(NNEW(n_CLASS_ATTRIBUTES));
717 NMORE($$, $1);
718 $$->appendChild(NTYPE($2, n_CLASS_NAME));
719 $$->appendChild($3);
720 $$->appendChild(NNEW(n_EMPTY));
721 $$->appendChild(NEXPAND($4, $5, $6));
722 NMORE($$, $6);
723
724 $$ = NNEW(n_STATEMENT)->appendChild($$);
725 }
726 ;
727
728 class_entry_type:
729 T_CLASS {
730 NTYPE($1, n_CLASS_ATTRIBUTES);
731 $$ = $1;
732 }
733 | T_ABSTRACT T_CLASS {
734 NTYPE($2, n_CLASS_ATTRIBUTES);
735 NMORE($2, $1);
736 $2->appendChild(NTYPE($1, n_STRING));
737
738 $$ = $2;
739 }
740 | T_FINAL T_CLASS {
741 NTYPE($2, n_CLASS_ATTRIBUTES);
742 NMORE($2, $1);
743 $2->appendChild(NTYPE($1, n_STRING));
744
745 $$ = $2;
746 }
747 | T_TRAIT {
748 $$ = NNEW(n_CLASS_ATTRIBUTES);
749 $$->appendChild(NTYPE($1, n_STRING));
750 }
751 ;
752
753 extends_from:
754 /* empty */ {
755 $$ = NNEW(n_EMPTY);
756 }
757 | T_EXTENDS fully_qualified_class_name {
758 $$ = NTYPE($1, n_EXTENDS_LIST)->appendChild($2);
759 }
760 ;
761
762 interface_entry:
763 T_INTERFACE
764 ;
765
766 interface_extends_list:
767 /* empty */ {
768 $$ = NNEW(n_EMPTY);
769 }
770 | T_EXTENDS interface_list {
771 NTYPE($1, n_EXTENDS_LIST);
772 $1->appendChildren($2);
773 $$ = $1;
774 }
775 ;
776
777 implements_list:
778 /* empty */ {
779 $$ = NNEW(n_EMPTY);
780 }
781 | T_IMPLEMENTS interface_list {
782 NTYPE($1, n_IMPLEMENTS_LIST);
783 $1->appendChildren($2);
784 $$ = $1;
785 }
786 ;
787
788 interface_list:
789 fully_qualified_class_name {
790 $$ = NNEW(n_IMPLEMENTS_LIST)->appendChild($1);
791 }
792 | interface_list ',' fully_qualified_class_name {
793 $$ = $1->appendChild($3);
794 }
795 ;
796
797 foreach_optional_arg:
798 /* empty */ {
799 $$ = NNEW(n_EMPTY);
800 }
801 | T_DOUBLE_ARROW foreach_variable {
802 $$ = $2;
803 }
804 ;
805
806 foreach_variable:
807 variable
808 | '&' variable {
809 NTYPE($1, n_VARIABLE_REFERENCE);
810 $1->appendChild($2);
811 $$ = $1;
812 }
813 ;
814
815 for_statement:
816 statement
817 | ':' inner_statement_list T_ENDFOR ';' {
818 NMORE($2, $1);
819 NMORE($2, $4);
820 $$ = $2;
821 }
822 ;
823
824 foreach_statement:
825 statement
826 | ':' inner_statement_list T_ENDFOREACH ';' {
827 NMORE($2, $1);
828 NMORE($2, $4);
829 $$ = $2;
830 }
831 ;
832
833 declare_statement:
834 statement
835 | ':' inner_statement_list T_ENDDECLARE ';' {
836 NMORE($2, $1);
837 NMORE($2, $4);
838 $$ = $2;
839 }
840 ;
841
842 declare_list:
843 T_STRING '=' static_scalar {
844 $$ = NNEW(n_DECLARE_DECLARATION);
845 $$->appendChild(NTYPE($1, n_STRING));
846 $$->appendChild($3);
847 $$ = NNEW(n_DECLARE_DECLARATION_LIST)->appendChild($$);
848 }
849 | declare_list ',' T_STRING '=' static_scalar {
850 $$ = NNEW(n_DECLARE_DECLARATION);
851 $$->appendChild(NTYPE($3, n_STRING));
852 $$->appendChild($5);
853
854 $1->appendChild($$);
855 $$ = $1;
856 }
857 ;
858
859 switch_case_list:
860 '{' case_list '}' {
861 $$ = NEXPAND($1, $2, $3);
862 }
863 | '{' ';' case_list '}' {
864 // ...why does this rule exist?
865
866 NTYPE($2, n_STATEMENT);
867 $1->appendChild(NNEW(n_EMPTY));
868
869 $$ = NNEW(n_STATEMENT_LIST)->appendChild($2);
870 $$->appendChildren($3);
871 NEXPAND($1, $$, $4);
872 }
873 | ':' case_list T_ENDSWITCH ';' {
874 NMORE($2, $4);
875 NMORE($2, $1);
876 $$ = $2;
877 }
878 | ':' ';' case_list T_ENDSWITCH ';' {
879 NTYPE($2, n_STATEMENT);
880 $1->appendChild(NNEW(n_EMPTY));
881
882 $$ = NNEW(n_STATEMENT_LIST)->appendChild($2);
883 $$->appendChildren($3);
884 NMORE($$, $5);
885 NMORE($$, $1);
886 }
887 ;
888
889 case_list:
890 /* empty */ {
891 $$ = NNEW(n_STATEMENT_LIST);
892 }
893 | case_list T_CASE expr case_separator inner_statement_list {
894 NTYPE($2, n_CASE);
895 $2->appendChild($3);
896 $2->appendChild($5);
897
898 $1->appendChild($2);
899 $$ = $1;
900 }
901 | case_list T_DEFAULT case_separator inner_statement_list {
902 NTYPE($2, n_DEFAULT);
903 $2->appendChild($4);
904
905 $1->appendChild($2);
906 $$ = $1;
907 }
908 ;
909
910 case_separator:
911 ':'
912 | ';'
913 ;
914
915 while_statement:
916 statement
917 | ':' inner_statement_list T_ENDWHILE ';' {
918 NMORE($2, $4);
919 NMORE($2, $1);
920 $$ = $2;
921 }
922 ;
923
924 elseif_list:
925 /* empty */ {
926 $$ = NNEW(n_CONDITION_LIST);
927 }
928 | elseif_list T_ELSEIF '(' expr ')' statement {
929 NTYPE($2, n_ELSEIF);
930 $2->appendChild(NSPAN($3, n_CONTROL_CONDITION, $5)->appendChild($4));
931 $2->appendChild($6);
932
933 $$ = $1->appendChild($2);
934 }
935 ;
936
937 new_elseif_list:
938 /* empty */ {
939 $$ = NNEW(n_CONDITION_LIST);
940 }
941 | new_elseif_list T_ELSEIF '(' expr ')' ':' inner_statement_list {
942 NTYPE($2, n_ELSEIF);
943 $2->appendChild($4);
944 $2->appendChild($7);
945
946 $$ = $1->appendChild($2);
947 }
948 ;
949
950 else_single:
951 /* empty */ {
952 $$ = NNEW(n_EMPTY);
953 }
954 | T_ELSE statement {
955 NTYPE($1, n_ELSE);
956 $1->appendChild($2);
957 $$ = $1;
958 }
959 ;
960
961 new_else_single:
962 /* empty */ {
963 $$ = NNEW(n_EMPTY);
964 }
965 | T_ELSE ':' inner_statement_list {
966 NTYPE($1, n_ELSE);
967 $1->appendChild($3);
968 $$ = $1;
969 }
970 ;
971
972 parameter_list:
973 non_empty_parameter_list
974 | /* empty */ {
975 $$ = NNEW(n_DECLARATION_PARAMETER_LIST);
976 }
977 ;
978
979 non_empty_parameter_list:
980 optional_type parameter {
981 $$ = NNEW(n_DECLARATION_PARAMETER);
982 $$->appendChild($1);
983 $$->appendChild($2);
984 $$->appendChild(NNEW(n_EMPTY));
985
986 $$ = NNEW(n_DECLARATION_PARAMETER_LIST)->appendChild($$);
987 }
988 | optional_type '&' parameter {
989 $$ = NNEW(n_DECLARATION_PARAMETER);
990 $$->appendChild($1);
991 $$->appendChild(NTYPE($2, n_VARIABLE_REFERENCE));
992 $2->appendChild($3);
993 $$->appendChild(NNEW(n_EMPTY));
994
995 $$ = NNEW(n_DECLARATION_PARAMETER_LIST)->appendChild($$);
996 }
997 | optional_type '&' parameter '=' static_scalar {
998 $$ = NNEW(n_DECLARATION_PARAMETER);
999 $$->appendChild($1);
1000 $$->appendChild(NTYPE($2, n_VARIABLE_REFERENCE));
1001 $2->appendChild($3);
1002 $$->appendChild($5);
1003
1004 $$ = NNEW(n_DECLARATION_PARAMETER_LIST)->appendChild($$);
1005 }
1006 | optional_type parameter '=' static_scalar {
1007 $$ = NNEW(n_DECLARATION_PARAMETER);
1008 $$->appendChild($1);
1009 $$->appendChild($2);
1010 $$->appendChild($4);
1011
1012 $$ = NNEW(n_DECLARATION_PARAMETER_LIST)->appendChild($$);
1013 }
1014 | non_empty_parameter_list ',' optional_type parameter {
1015 $$ = NNEW(n_DECLARATION_PARAMETER);
1016 $$->appendChild($3);
1017 $$->appendChild($4);
1018 $$->appendChild(NNEW(n_EMPTY));
1019
1020 $$ = $1->appendChild($$);
1021 }
1022 | non_empty_parameter_list ',' optional_type '&' parameter {
1023 $$ = NNEW(n_DECLARATION_PARAMETER);
1024 $$->appendChild($3);
1025 $$->appendChild(NTYPE($4, n_VARIABLE_REFERENCE));
1026 $4->appendChild($5);
1027 $$->appendChild(NNEW(n_EMPTY));
1028
1029 $$ = $1->appendChild($$);
1030 }
1031 | non_empty_parameter_list ',' optional_type '&'
1032 parameter '=' static_scalar {
1033 $$ = NNEW(n_DECLARATION_PARAMETER);
1034 $$->appendChild($3);
1035 $$->appendChild(NTYPE($4, n_VARIABLE_REFERENCE));
1036 $4->appendChild($5);
1037 $$->appendChild($7);
1038
1039 $$ = $1->appendChild($$);
1040 }
1041 | non_empty_parameter_list ',' optional_type
1042 parameter '=' static_scalar {
1043 $$ = NNEW(n_DECLARATION_PARAMETER);
1044 $$->appendChild($3);
1045 $$->appendChild($4);
1046 $$->appendChild($6);
1047
1048 $$ = $1->appendChild($$);
1049 }
1050 ;
1051
1052 parameter:
1053 T_ELLIPSIS T_VARIABLE {
1054 NTYPE($1, n_UNPACK);
1055 $$ = $1->appendChild(NTYPE($2, n_VARIABLE));
1056 }
1057 | T_VARIABLE {
1058 $$ = NTYPE($1, n_VARIABLE);
1059 }
1060 ;
1061
1062 optional_type:
1063 /* empty */ {
1064 $$ = NNEW(n_EMPTY);
1065 }
1066 | type
1067 | '?' type {
1068 $$ = NNEW(n_NULLABLE_TYPE);
1069 $$->appendChild($2);
1070 }
1071 ;
1072
1073 type:
1074 fully_qualified_class_name {
1075 $$ = $1;
1076 }
1077 | T_ARRAY {
1078 $$ = NTYPE($1, n_TYPE_NAME);
1079 }
1080 | T_CALLABLE {
1081 $$ = NTYPE($1, n_TYPE_NAME);
1082 }
1083 ;
1084
1085 return_type:
1086 /* empty */ {
1087 $$ = NNEW(n_EMPTY);
1088 }
1089 | ':' optional_type {
1090 $$ = NNEW(n_DECLARATION_RETURN);
1091 $$->appendChild($2);
1092 }
1093 ;
1094
1095 function_call_parameter_list:
1096 non_empty_function_call_parameter_list
1097 | /* empty */ {
1098 $$ = NNEW(n_CALL_PARAMETER_LIST);
1099 }
1100 ;
1101
1102 non_empty_function_call_parameter_list:
1103 argument {
1104 $$ = NNEW(n_CALL_PARAMETER_LIST)->appendChild($1);
1105 }
1106 | non_empty_function_call_parameter_list ',' argument {
1107 $$ = $1->appendChild($3);
1108 }
1109 ;
1110
1111 argument:
1112 expr
1113 | T_ELLIPSIS expr {
1114 NTYPE($1, n_UNPACK);
1115 $$ = $1->appendChild($2);
1116 }
1117 | '&' w_variable {
1118 NTYPE($1, n_VARIABLE_REFERENCE);
1119 $$ = $1->appendChild($2);
1120 }
1121 ;
1122
1123 global_var_list:
1124 global_var_list ',' global_var {
1125 $1->appendChild($3);
1126 $$ = $1;
1127 }
1128 | global_var {
1129 $$ = NNEW(n_GLOBAL_DECLARATION_LIST);
1130 $$->appendChild($1);
1131 }
1132 ;
1133
1134 global_var:
1135 T_VARIABLE {
1136 $$ = NTYPE($1, n_VARIABLE);
1137 }
1138 | '$' r_variable {
1139 $$ = NTYPE($1, n_VARIABLE_VARIABLE);
1140 $$->appendChild($2);
1141 }
1142 | '$' '{' expr '}' {
1143 $$ = NTYPE($1, n_VARIABLE_VARIABLE);
1144 $$->appendChild($3);
1145 }
1146 ;
1147
1148 static_var_list:
1149 static_var_list ',' T_VARIABLE {
1150 NTYPE($3, n_VARIABLE);
1151 $$ = NNEW(n_STATIC_DECLARATION);
1152 $$->appendChild($3);
1153 $$->appendChild(NNEW(n_EMPTY));
1154
1155 $$ = $1->appendChild($$);
1156 }
1157 | static_var_list ',' T_VARIABLE '=' static_scalar {
1158 NTYPE($3, n_VARIABLE);
1159 $$ = NNEW(n_STATIC_DECLARATION);
1160 $$->appendChild($3);
1161 $$->appendChild($5);
1162
1163 $$ = $1->appendChild($$);
1164 }
1165 | T_VARIABLE {
1166 NTYPE($1, n_VARIABLE);
1167 $$ = NNEW(n_STATIC_DECLARATION);
1168 $$->appendChild($1);
1169 $$->appendChild(NNEW(n_EMPTY));
1170
1171 $$ = NNEW(n_STATIC_DECLARATION_LIST)->appendChild($$);
1172 }
1173 | T_VARIABLE '=' static_scalar {
1174 NTYPE($1, n_VARIABLE);
1175 $$ = NNEW(n_STATIC_DECLARATION);
1176 $$->appendChild($1);
1177 $$->appendChild($3);
1178
1179 $$ = NNEW(n_STATIC_DECLARATION_LIST)->appendChild($$);
1180 }
1181 ;
1182
1183 class_statement_list:
1184 class_statement_list class_statement {
1185 $$ = $1->appendChild($2);
1186 }
1187 | /* empty */ {
1188 $$ = NNEW(n_STATEMENT_LIST);
1189 }
1190 ;
1191
1192 class_statement:
1193 variable_modifiers class_variable_declaration ';' {
1194 $$ = NNEW(n_CLASS_MEMBER_DECLARATION_LIST);
1195 $$->appendChild($1);
1196 $$->appendChildren($2);
1197
1198 $$ = NNEW(n_STATEMENT)->appendChild($$);
1199 NMORE($$, $3);
1200 }
1201 | class_constant_declaration ';' {
1202 $$ = NNEW(n_STATEMENT)->appendChild($1);
1203 NMORE($$, $2);
1204 }
1205 | trait_use_statement {
1206 $$ = $1;
1207 }
1208 | method_modifiers function {
1209 /* empty */
1210 } is_reference T_STRING '(' parameter_list ')' return_type method_body {
1211 $$ = NNEW(n_METHOD_DECLARATION);
1212 NMORE($$, $2);
1213 $$->appendChild($1);
1214 $$->appendChild($4);
1215 $$->appendChild(NTYPE($5, n_STRING));
1216 $$->appendChild(NEXPAND($6, $7, $8));
1217 $$->appendChild(NNEW(n_EMPTY));
1218 $$->appendChild($9);
1219 $$->appendChild($10);
1220
1221 $$ = NNEW(n_STATEMENT)->appendChild($$);
1222 }
1223 ;
1224
1225 trait_use_statement:
1226 T_USE trait_list trait_adaptations {
1227 $$ = NTYPE($1, n_TRAIT_USE);
1228 $$->appendChildren($2);
1229 $$->appendChild($3);
1230 }
1231 ;
1232
1233 trait_list:
1234 fully_qualified_class_name {
1235 $$ = NNEW(n_TRAIT_USE_LIST)->appendChild($1);
1236 }
1237 | trait_list ',' fully_qualified_class_name {
1238 $$ = $1->appendChild($3);
1239 }
1240 ;
1241
1242 trait_adaptations:
1243 ';' {
1244 $$ = NNEW(n_EMPTY);
1245 }
1246 | '{' trait_adaptation_list '}' {
1247 $$ = NEXPAND($1, $2, $3);
1248 }
1249 ;
1250
1251 trait_adaptation_list:
1252 /* empty */ {
1253 $$ = NNEW(n_TRAIT_ADAPTATION_LIST);
1254 }
1255 | non_empty_trait_adaptation_list {
1256 $$ = $1;
1257 }
1258 ;
1259
1260 non_empty_trait_adaptation_list:
1261 trait_adaptation_statement {
1262 $$ = NNEW(n_TRAIT_ADAPTATION_LIST);
1263 $$->appendChild($1);
1264 }
1265 | non_empty_trait_adaptation_list trait_adaptation_statement {
1266 $1->appendChild($2);
1267 $$ = $1;
1268 }
1269 ;
1270
1271 trait_adaptation_statement:
1272 trait_precedence ';' {
1273 $$ = NMORE($1, $2);
1274 }
1275 | trait_alias ';' {
1276 $$ = NMORE($1, $2);
1277 }
1278 ;
1279
1280 trait_precedence:
1281 trait_method_reference_fully_qualified T_INSTEADOF trait_reference_list {
1282 $$ = NNEW(n_TRAIT_INSTEADOF);
1283 $$->appendChild($1);
1284 $$->appendChild($3);
1285 }
1286 ;
1287
1288 trait_reference_list:
1289 fully_qualified_class_name {
1290 $$ = NNEW(n_TRAIT_REFERENCE_LIST);
1291 $$->appendChild($1);
1292 }
1293 | trait_reference_list ',' fully_qualified_class_name {
1294 $1->appendChild($3);
1295 $$ = $1;
1296 }
1297 ;
1298
1299 trait_method_reference:
1300 T_STRING {
1301 $$ = NNEW(n_TRAIT_METHOD_REFERENCE);
1302 $$->appendChild(NTYPE($1, n_STRING));
1303 }
1304 | trait_method_reference_fully_qualified {
1305 $$ = $1;
1306 }
1307 ;
1308
1309 trait_method_reference_fully_qualified:
1310 fully_qualified_class_name T_PAAMAYIM_NEKUDOTAYIM T_STRING {
1311 NTYPE($2, n_TRAIT_METHOD_REFERENCE);
1312 NEXPAND($1, $2, NTYPE($3, n_STRING));
1313 $$ = $2;
1314 }
1315 ;
1316
1317 trait_alias:
1318 trait_method_reference T_AS trait_modifiers T_STRING {
1319 $$ = NNEW(n_TRAIT_AS);
1320 $$->appendChild($1);
1321 $$->appendChild($3);
1322 $$->appendChild(NTYPE($4, n_STRING));
1323 }
1324 | trait_method_reference T_AS member_modifier {
1325 $$ = NNEW(n_TRAIT_AS);
1326 $$->appendChild($1);
1327 $$->appendChild($3);
1328 $$->appendChild(NNEW(n_EMPTY));
1329 }
1330 ;
1331
1332 trait_modifiers:
1333 /* empty */ {
1334 $$ = NNEW(n_EMPTY);
1335 }
1336 | member_modifier {
1337 $$ = NNEW(n_METHOD_MODIFIER_LIST);
1338 $$->appendChild($1);
1339 }
1340 ;
1341
1342
1343 method_body:
1344 ';' /* abstract method */ {
1345 $$ = NNEW(n_EMPTY);
1346 }
1347 | '{' inner_statement_list '}' {
1348 $$ = NEXPAND($1, $2, $3);
1349 }
1350 ;
1351
1352 variable_modifiers:
1353 non_empty_member_modifiers
1354 | T_VAR {
1355 $$ = NNEW(n_CLASS_MEMBER_MODIFIER_LIST);
1356 $$->appendChild(NTYPE($1, n_STRING));
1357 }
1358 ;
1359
1360 method_modifiers:
1361 /* empty */ {
1362 $$ = NNEW(n_METHOD_MODIFIER_LIST);
1363 }
1364 | non_empty_member_modifiers {
1365 NTYPE($1, n_METHOD_MODIFIER_LIST);
1366 $$ = $1;
1367 }
1368 ;
1369
1370 non_empty_member_modifiers:
1371 member_modifier {
1372 $$ = NNEW(n_CLASS_MEMBER_MODIFIER_LIST);
1373 $$->appendChild($1);
1374 }
1375 | non_empty_member_modifiers member_modifier {
1376 $$ = $1->appendChild($2);
1377 }
1378 ;
1379
1380 member_modifier:
1381 basic_member_modifier {
1382 $$ = NTYPE($1, n_STRING);
1383 }
1384 ;
1385
1386 basic_member_modifier:
1387 T_PUBLIC
1388 | T_PROTECTED
1389 | T_PRIVATE
1390 | T_STATIC
1391 | T_ABSTRACT
1392 | T_FINAL
1393 ;
1394
1395 class_variable_declaration:
1396 class_variable_declaration ',' T_VARIABLE {
1397 $$ = NNEW(n_CLASS_MEMBER_DECLARATION);
1398 $$->appendChild(NTYPE($3, n_VARIABLE));
1399 $$->appendChild(NNEW(n_EMPTY));
1400
1401 $$ = $1->appendChild($$);
1402 }
1403 | class_variable_declaration ',' T_VARIABLE '=' static_scalar {
1404 $$ = NNEW(n_CLASS_MEMBER_DECLARATION);
1405 $$->appendChild(NTYPE($3, n_VARIABLE));
1406 $$->appendChild($5);
1407
1408 $$ = $1->appendChild($$);
1409 }
1410 | T_VARIABLE {
1411 $$ = NNEW(n_CLASS_MEMBER_DECLARATION);
1412 $$->appendChild(NTYPE($1, n_VARIABLE));
1413 $$->appendChild(NNEW(n_EMPTY));
1414
1415 $$ = NNEW(n_CLASS_MEMBER_DECLARATION_LIST)->appendChild($$);
1416 }
1417 | T_VARIABLE '=' static_scalar {
1418 $$ = NNEW(n_CLASS_MEMBER_DECLARATION);
1419 $$->appendChild(NTYPE($1, n_VARIABLE));
1420 $$->appendChild($3);
1421
1422 $$ = NNEW(n_CLASS_MEMBER_DECLARATION_LIST)->appendChild($$);
1423 }
1424 ;
1425
1426 class_constant_declaration:
1427 class_constant_declaration ',' T_STRING '=' static_scalar {
1428 $$ = NNEW(n_CLASS_CONSTANT_DECLARATION);
1429 $$->appendChild(NTYPE($3, n_STRING));
1430 $$->appendChild($5);
1431
1432 $1->appendChild($$);
1433
1434 $$ = $1;
1435 }
1436 | T_CONST T_STRING '=' static_scalar {
1437 NTYPE($1, n_CLASS_CONSTANT_DECLARATION_LIST);
1438 $$ = NNEW(n_CLASS_CONSTANT_DECLARATION);
1439 $$->appendChild(NTYPE($2, n_STRING));
1440 $$->appendChild($4);
1441 $1->appendChild($$);
1442
1443 $$ = $1;
1444 }
1445 ;
1446
1447 echo_expr_list:
1448 echo_expr_list ',' expr {
1449 $1->appendChild($3);
1450 }
1451 | expr {
1452 $$ = NNEW(n_ECHO_LIST);
1453 $$->appendChild($1);
1454 }
1455 ;
1456
1457 for_expr:
1458 /* empty */ {
1459 $$ = NNEW(n_EMPTY);
1460 }
1461 | non_empty_for_expr
1462 ;
1463
1464
1465 non_empty_for_expr:
1466 non_empty_for_expr ',' expr {
1467 $1->appendChild($3);
1468 }
1469 | expr {
1470 $$ = NNEW(n_EXPRESSION_LIST);
1471 $$->appendChild($1);
1472 }
1473 ;
1474
1475 expr_without_variable:
1476 T_LIST '(' assignment_list ')' '=' expr {
1477 NTYPE($1, n_LIST);
1478 $1->appendChild(NEXPAND($2, $3, $4));
1479 $$ = NNEW(n_BINARY_EXPRESSION);
1480 $$->appendChild($1);
1481 $$->appendChild(NTYPE($5, n_OPERATOR));
1482 $$->appendChild($6);
1483 }
1484 | variable '=' expr {
1485 $$ = NNEW(n_BINARY_EXPRESSION);
1486 $$->appendChild($1);
1487 $$->appendChild(NTYPE($2, n_OPERATOR));
1488 $$->appendChild($3);
1489 }
1490 | variable '=' '&' variable {
1491 $$ = NNEW(n_BINARY_EXPRESSION);
1492 $$->appendChild($1);
1493 $$->appendChild(NTYPE($2, n_OPERATOR));
1494
1495 NTYPE($3, n_VARIABLE_REFERENCE);
1496 $3->appendChild($4);
1497
1498 $$->appendChild($3);
1499 }
1500 | variable '=' '&' T_NEW class_name_reference ctor_arguments {
1501 $$ = NNEW(n_BINARY_EXPRESSION);
1502 $$->appendChild($1);
1503 $$->appendChild(NTYPE($2, n_OPERATOR));
1504
1505 NTYPE($4, n_NEW);
1506 $4->appendChild($5);
1507 $4->appendChild($6);
1508
1509 NTYPE($3, n_VARIABLE_REFERENCE);
1510 $3->appendChild($4);
1511
1512 $$->appendChild($3);
1513 }
1514 | T_CLONE expr {
1515 $$ = NNEW(n_UNARY_PREFIX_EXPRESSION);
1516 $$->appendChild(NTYPE($1, n_OPERATOR));
1517 $$->appendChild($2);
1518 }
1519 | variable T_PLUS_EQUAL expr {
1520 $$ = NNEW(n_BINARY_EXPRESSION);
1521 $$->appendChild($1);
1522 $$->appendChild(NTYPE($2, n_OPERATOR));
1523 $$->appendChild($3);
1524 }
1525 | variable T_MINUS_EQUAL expr {
1526 $$ = NNEW(n_BINARY_EXPRESSION);
1527 $$->appendChild($1);
1528 $$->appendChild(NTYPE($2, n_OPERATOR));
1529 $$->appendChild($3);
1530 }
1531 | variable T_MUL_EQUAL expr {
1532 $$ = NNEW(n_BINARY_EXPRESSION);
1533 $$->appendChild($1);
1534 $$->appendChild(NTYPE($2, n_OPERATOR));
1535 $$->appendChild($3);
1536 }
1537 | variable T_DIV_EQUAL expr {
1538 $$ = NNEW(n_BINARY_EXPRESSION);
1539 $$->appendChild($1);
1540 $$->appendChild(NTYPE($2, n_OPERATOR));
1541 $$->appendChild($3);
1542 }
1543 | variable T_CONCAT_EQUAL expr {
1544 $$ = NNEW(n_BINARY_EXPRESSION);
1545 $$->appendChild($1);
1546 $$->appendChild(NTYPE($2, n_OPERATOR));
1547 $$->appendChild($3);
1548 }
1549 | variable T_MOD_EQUAL expr {
1550 $$ = NNEW(n_BINARY_EXPRESSION);
1551 $$->appendChild($1);
1552 $$->appendChild(NTYPE($2, n_OPERATOR));
1553 $$->appendChild($3);
1554 }
1555 | variable T_AND_EQUAL expr {
1556 $$ = NNEW(n_BINARY_EXPRESSION);
1557 $$->appendChild($1);
1558 $$->appendChild(NTYPE($2, n_OPERATOR));
1559 $$->appendChild($3);
1560 }
1561 | variable T_OR_EQUAL expr {
1562 $$ = NNEW(n_BINARY_EXPRESSION);
1563 $$->appendChild($1);
1564 $$->appendChild(NTYPE($2, n_OPERATOR));
1565 $$->appendChild($3);
1566 }
1567 | variable T_XOR_EQUAL expr {
1568 $$ = NNEW(n_BINARY_EXPRESSION);
1569 $$->appendChild($1);
1570 $$->appendChild(NTYPE($2, n_OPERATOR));
1571 $$->appendChild($3);
1572 }
1573 | variable T_SL_EQUAL expr {
1574 $$ = NNEW(n_BINARY_EXPRESSION);
1575 $$->appendChild($1);
1576 $$->appendChild(NTYPE($2, n_OPERATOR));
1577 $$->appendChild($3);
1578 }
1579 | variable T_SR_EQUAL expr {
1580 $$ = NNEW(n_BINARY_EXPRESSION);
1581 $$->appendChild($1);
1582 $$->appendChild(NTYPE($2, n_OPERATOR));
1583 $$->appendChild($3);
1584 }
1585 | rw_variable T_INC {
1586 $$ = NNEW(n_UNARY_POSTFIX_EXPRESSION);
1587 $$->appendChild($1);
1588 $$->appendChild(NTYPE($2, n_OPERATOR));
1589 }
1590 | T_INC rw_variable {
1591 $$ = NNEW(n_UNARY_PREFIX_EXPRESSION);
1592 $$->appendChild(NTYPE($1, n_OPERATOR));
1593 $$->appendChild($2);
1594 }
1595 | rw_variable T_DEC {
1596 $$ = NNEW(n_UNARY_POSTFIX_EXPRESSION);
1597 $$->appendChild($1);
1598 $$->appendChild(NTYPE($2, n_OPERATOR));
1599 }
1600 | T_DEC rw_variable {
1601 $$ = NNEW(n_UNARY_PREFIX_EXPRESSION);
1602 $$->appendChild(NTYPE($1, n_OPERATOR));
1603 $$->appendChild($2);
1604 }
1605 | expr T_BOOLEAN_OR expr {
1606 $$ = NNEW(n_BINARY_EXPRESSION);
1607 $$->appendChild($1);
1608 $$->appendChild(NTYPE($2, n_OPERATOR));
1609 $$->appendChild($3);
1610 }
1611 | expr T_BOOLEAN_AND expr {
1612 $$ = NNEW(n_BINARY_EXPRESSION);
1613 $$->appendChild($1);
1614 $$->appendChild(NTYPE($2, n_OPERATOR));
1615 $$->appendChild($3);
1616 }
1617 | expr T_LOGICAL_OR expr {
1618 $$ = NNEW(n_BINARY_EXPRESSION);
1619 $$->appendChild($1);
1620 $$->appendChild(NTYPE($2, n_OPERATOR));
1621 $$->appendChild($3);
1622 }
1623 | expr T_LOGICAL_AND expr {
1624 $$ = NNEW(n_BINARY_EXPRESSION);
1625 $$->appendChild($1);
1626 $$->appendChild(NTYPE($2, n_OPERATOR));
1627 $$->appendChild($3);
1628 }
1629 | expr T_LOGICAL_XOR expr {
1630 $$ = NNEW(n_BINARY_EXPRESSION);
1631 $$->appendChild($1);
1632 $$->appendChild(NTYPE($2, n_OPERATOR));
1633 $$->appendChild($3);
1634 }
1635 | expr '|' expr {
1636 $$ = NNEW(n_BINARY_EXPRESSION);
1637 $$->appendChild($1);
1638 $$->appendChild(NTYPE($2, n_OPERATOR));
1639 $$->appendChild($3);
1640 }
1641 | expr '&' expr {
1642 $$ = NNEW(n_BINARY_EXPRESSION);
1643 $$->appendChild($1);
1644 $$->appendChild(NTYPE($2, n_OPERATOR));
1645 $$->appendChild($3);
1646 }
1647 | expr '^' expr {
1648 $$ = NNEW(n_BINARY_EXPRESSION);
1649 $$->appendChild($1);
1650 $$->appendChild(NTYPE($2, n_OPERATOR));
1651 $$->appendChild($3);
1652 }
1653 | expr '.' expr {
1654
1655 /* The concatenation operator generates n_CONCATENATION_LIST instead of
1656 n_BINARY_EXPRESSION because we tend to run into stack depth issues in a
1657 lot of real-world cases otherwise (e.g., in PHP and JSON decoders). */
1658
1659 if ($1->type == n_CONCATENATION_LIST && $3->type == n_CONCATENATION_LIST) {
1660 $1->appendChild(NTYPE($2, n_OPERATOR));
1661 $1->appendChildren($3);
1662 $$ = $1;
1663 } else if ($1->type == n_CONCATENATION_LIST) {
1664 $1->appendChild(NTYPE($2, n_OPERATOR));
1665 $1->appendChild($3);
1666 $$ = $1;
1667 } else if ($3->type == n_CONCATENATION_LIST) {
1668 $$ = NNEW(n_CONCATENATION_LIST);
1669 $$->appendChild($1);
1670 $$->appendChild(NTYPE($2, n_OPERATOR));
1671 $$->appendChildren($3);
1672 } else {
1673 $$ = NNEW(n_CONCATENATION_LIST);
1674 $$->appendChild($1);
1675 $$->appendChild(NTYPE($2, n_OPERATOR));
1676 $$->appendChild($3);
1677 }
1678 }
1679 | expr '+' expr {
1680 $$ = NNEW(n_BINARY_EXPRESSION);
1681 $$->appendChild($1);
1682 $$->appendChild(NTYPE($2, n_OPERATOR));
1683 $$->appendChild($3);
1684 }
1685 | expr '-' expr {
1686 $$ = NNEW(n_BINARY_EXPRESSION);
1687 $$->appendChild($1);
1688 $$->appendChild(NTYPE($2, n_OPERATOR));
1689 $$->appendChild($3);
1690 }
1691 | expr '*' expr {
1692 $$ = NNEW(n_BINARY_EXPRESSION);
1693 $$->appendChild($1);
1694 $$->appendChild(NTYPE($2, n_OPERATOR));
1695 $$->appendChild($3);
1696 }
1697 | expr '/' expr {
1698 $$ = NNEW(n_BINARY_EXPRESSION);
1699 $$->appendChild($1);
1700 $$->appendChild(NTYPE($2, n_OPERATOR));
1701 $$->appendChild($3);
1702 }
1703 | expr '%' expr {
1704 $$ = NNEW(n_BINARY_EXPRESSION);
1705 $$->appendChild($1);
1706 $$->appendChild(NTYPE($2, n_OPERATOR));
1707 $$->appendChild($3);
1708 }
1709 | expr T_SL expr {
1710 $$ = NNEW(n_BINARY_EXPRESSION);
1711 $$->appendChild($1);
1712 $$->appendChild(NTYPE($2, n_OPERATOR));
1713 $$->appendChild($3);
1714 }
1715 | expr T_SR expr {
1716 $$ = NNEW(n_BINARY_EXPRESSION);
1717 $$->appendChild($1);
1718 $$->appendChild(NTYPE($2, n_OPERATOR));
1719 $$->appendChild($3);
1720 }
1721 | '+' expr %prec T_INC {
1722 $$ = NNEW(n_UNARY_PREFIX_EXPRESSION);
1723 $$->appendChild(NTYPE($1, n_OPERATOR));
1724 $$->appendChild($2);
1725 }
1726 | '-' expr %prec T_INC {
1727 $$ = NNEW(n_UNARY_PREFIX_EXPRESSION);
1728 $$->appendChild(NTYPE($1, n_OPERATOR));
1729 $$->appendChild($2);
1730 }
1731 | '!' expr {
1732 $$ = NNEW(n_UNARY_PREFIX_EXPRESSION);
1733 $$->appendChild(NTYPE($1, n_OPERATOR));
1734 $$->appendChild($2);
1735 }
1736 | '~' expr {
1737 $$ = NNEW(n_UNARY_PREFIX_EXPRESSION);
1738 $$->appendChild(NTYPE($1, n_OPERATOR));
1739 $$->appendChild($2);
1740 }
1741 | expr T_IS_IDENTICAL expr {
1742 $$ = NNEW(n_BINARY_EXPRESSION);
1743 $$->appendChild($1);
1744 $$->appendChild(NTYPE($2, n_OPERATOR));
1745 $$->appendChild($3);
1746 }
1747 | expr T_IS_NOT_IDENTICAL expr {
1748 $$ = NNEW(n_BINARY_EXPRESSION);
1749 $$->appendChild($1);
1750 $$->appendChild(NTYPE($2, n_OPERATOR));
1751 $$->appendChild($3);
1752 }
1753 | expr T_IS_EQUAL expr {
1754 $$ = NNEW(n_BINARY_EXPRESSION);
1755 $$->appendChild($1);
1756 $$->appendChild(NTYPE($2, n_OPERATOR));
1757 $$->appendChild($3);
1758 }
1759 | expr T_IS_NOT_EQUAL expr {
1760 $$ = NNEW(n_BINARY_EXPRESSION);
1761 $$->appendChild($1);
1762 $$->appendChild(NTYPE($2, n_OPERATOR));
1763 $$->appendChild($3);
1764 }
1765 | expr '<' expr {
1766 $$ = NNEW(n_BINARY_EXPRESSION);
1767 $$->appendChild($1);
1768 $$->appendChild(NTYPE($2, n_OPERATOR));
1769 $$->appendChild($3);
1770 }
1771 | expr T_IS_SMALLER_OR_EQUAL expr {
1772 $$ = NNEW(n_BINARY_EXPRESSION);
1773 $$->appendChild($1);
1774 $$->appendChild(NTYPE($2, n_OPERATOR));
1775 $$->appendChild($3);
1776 }
1777 | expr '>' expr {
1778 $$ = NNEW(n_BINARY_EXPRESSION);
1779 $$->appendChild($1);
1780 $$->appendChild(NTYPE($2, n_OPERATOR));
1781 $$->appendChild($3);
1782 }
1783 | expr T_IS_GREATER_OR_EQUAL expr {
1784 $$ = NNEW(n_BINARY_EXPRESSION);
1785 $$->appendChild($1);
1786 $$->appendChild(NTYPE($2, n_OPERATOR));
1787 $$->appendChild($3);
1788 }
1789 | expr T_SPACESHIP expr {
1790 $$ = NNEW(n_BINARY_EXPRESSION);
1791 $$->appendChild($1);
1792 $$->appendChild(NTYPE($2, n_OPERATOR));
1793 $$->appendChild($3);
1794 }
1795 | expr T_INSTANCEOF class_name_reference {
1796 $$ = NNEW(n_BINARY_EXPRESSION);
1797 $$->appendChild($1);
1798 $$->appendChild(NTYPE($2, n_OPERATOR));
1799 $$->appendChild($3);
1800 }
1801 | parenthesis_expr
1802 | new_expr
1803 | expr '?' expr ':' expr {
1804 $$ = NNEW(n_TERNARY_EXPRESSION);
1805 $$->appendChild($1);
1806 $$->appendChild(NTYPE($2, n_OPERATOR));
1807 $$->appendChild($3);
1808 $$->appendChild(NTYPE($4, n_OPERATOR));
1809 $$->appendChild($5);
1810 }
1811 | expr '?' ':' expr {
1812 $$ = NNEW(n_TERNARY_EXPRESSION);
1813 $$->appendChild($1);
1814 $$->appendChild(NTYPE($2, n_OPERATOR));
1815 $$->appendChild(NNEW(n_EMPTY));
1816 $$->appendChild(NTYPE($3, n_OPERATOR));
1817 $$->appendChild($4);
1818 }
1819 | expr T_COALESCE expr {
1820 $$ = NNEW(n_BINARY_EXPRESSION);
1821 $$->appendChild($1);
1822 $$->appendChild(NTYPE($2, n_OPERATOR));
1823 $$->appendChild($3);
1824 }
1825 | internal_functions_in_yacc
1826 | T_INT_CAST expr {
1827 $$ = NNEW(n_CAST_EXPRESSION);
1828 $$->appendChild(NTYPE($1, n_CAST));
1829 $$->appendChild($2);
1830 }
1831 | T_DOUBLE_CAST expr {
1832 $$ = NNEW(n_CAST_EXPRESSION);
1833 $$->appendChild(NTYPE($1, n_CAST));
1834 $$->appendChild($2);
1835 }
1836 | T_STRING_CAST expr {
1837 $$ = NNEW(n_CAST_EXPRESSION);
1838 $$->appendChild(NTYPE($1, n_CAST));
1839 $$->appendChild($2);
1840 }
1841 | T_ARRAY_CAST expr {
1842 $$ = NNEW(n_CAST_EXPRESSION);
1843 $$->appendChild(NTYPE($1, n_CAST));
1844 $$->appendChild($2);
1845 }
1846 | T_OBJECT_CAST expr {
1847 $$ = NNEW(n_CAST_EXPRESSION);
1848 $$->appendChild(NTYPE($1, n_CAST));
1849 $$->appendChild($2);
1850 }
1851 | T_BOOL_CAST expr {
1852 $$ = NNEW(n_CAST_EXPRESSION);
1853 $$->appendChild(NTYPE($1, n_CAST));
1854 $$->appendChild($2);
1855 }
1856 | T_UNSET_CAST expr {
1857 $$ = NNEW(n_CAST_EXPRESSION);
1858 $$->appendChild(NTYPE($1, n_CAST));
1859 $$->appendChild($2);
1860 }
1861 | T_EXIT exit_expr {
1862 $$ = NNEW(n_UNARY_PREFIX_EXPRESSION);
1863 $$->appendChild(NTYPE($1, n_OPERATOR));
1864 $$->appendChild($2);
1865 }
1866 | '@' expr {
1867 $$ = NNEW(n_UNARY_PREFIX_EXPRESSION);
1868 $$->appendChild(NTYPE($1, n_OPERATOR));
1869 $$->appendChild($2);
1870 }
1871 | T_BACKTICKS_EXPR {
1872 NTYPE($1, n_BACKTICKS_EXPRESSION);
1873 $$ = $1;
1874 }
1875 | scalar
1876 | combined_scalar_offset
1877 | combined_scalar
1878 | T_PRINT expr {
1879 $$ = NNEW(n_UNARY_PREFIX_EXPRESSION);
1880 $$->appendChild(NTYPE($1, n_OPERATOR));
1881 $$->appendChild($2);
1882 }
1883 | T_YIELD {
1884 NTYPE($1, n_YIELD);
1885 $1->appendChild(NNEW(n_EMPTY));
1886 $1->appendChild(NNEW(n_EMPTY));
1887 $$ = $1;
1888 }
1889 | function is_reference
1890 '(' parameter_list ')'
1891 lexical_vars return_type
1892 '{' inner_statement_list '}' {
1893 NSPAN($1, n_FUNCTION_DECLARATION, $9);
1894 $1->appendChild(NNEW(n_EMPTY));
1895 $1->appendChild($2);
1896 $1->appendChild(NNEW(n_EMPTY));
1897 $1->appendChild(NEXPAND($3, $4, $5));
1898 $1->appendChild($6);
1899 $1->appendChild($7);
1900 $1->appendChild(NEXPAND($8, $9, $10));
1901
1902 $$ = $1;
1903 }
1904 | T_STATIC function is_reference
1905 '(' parameter_list ')'
1906 lexical_vars return_type
1907 '{' inner_statement_list '}' {
1908 NSPAN($2, n_FUNCTION_DECLARATION, $10);
1909 NMORE($2, $1);
1910
1911 $$ = NNEW(n_FUNCTION_MODIFIER_LIST);
1912 $$->appendChild(NTYPE($1, n_STRING));
1913 $2->appendChild($1);
1914
1915 $2->appendChild(NNEW(n_EMPTY));
1916 $2->appendChild($3);
1917 $2->appendChild(NNEW(n_EMPTY));
1918 $2->appendChild(NEXPAND($4, $5, $6));
1919 $2->appendChild($7);
1920 $2->appendChild($8);
1921 $2->appendChild(NEXPAND($9, $10, $11));
1922
1923 $$ = $2;
1924 }
1925 ;
1926
1927 yield_expr:
1928 T_YIELD expr_without_variable {
1929 NTYPE($1, n_YIELD);
1930 $2->appendChild(NNEW(n_EMPTY));
1931 $1->appendChild($2);
1932 $$ = $1;
1933 }
1934 | T_YIELD variable {
1935 NTYPE($1, n_YIELD);
1936 $2->appendChild(NNEW(n_EMPTY));
1937 $1->appendChild($2);
1938 $$ = $1;
1939 }
1940 | T_YIELD expr T_DOUBLE_ARROW expr_without_variable {
1941 NTYPE($1, n_YIELD);
1942 $1->appendChild($2);
1943 $1->appendChild($4);
1944 $$ = $1;
1945 }
1946 | T_YIELD expr T_DOUBLE_ARROW variable {
1947 NTYPE($1, n_YIELD);
1948 $1->appendChild($2);
1949 $1->appendChild($4);
1950 $$ = $1;
1951 }
1952 ;
1953
1954 function:
1955 T_FUNCTION
1956 ;
1957
1958 lexical_vars:
1959 /* empty */ {
1960 $$ = NNEW(n_EMPTY);
1961 }
1962 | T_USE '(' lexical_var_list ')' {
1963 NTYPE($1, n_LEXICAL_VARIABLE_LIST);
1964 $1->appendChildren($3);
1965 $$ = $1;
1966 }
1967 ;
1968
1969 lexical_var_list:
1970 lexical_var_list ',' T_VARIABLE {
1971 $$ = $1->appendChild(NTYPE($3, n_VARIABLE));
1972 }
1973 | lexical_var_list ',' '&' T_VARIABLE {
1974 NTYPE($3, n_VARIABLE_REFERENCE);
1975 $3->appendChild(NTYPE($4, n_VARIABLE));
1976 $$ = $1->appendChild($3);
1977 }
1978 | T_VARIABLE {
1979 $$ = NNEW(n_LEXICAL_VARIABLE_LIST);
1980 $$->appendChild(NTYPE($1, n_VARIABLE));
1981 }
1982 | '&' T_VARIABLE {
1983 NTYPE($1, n_VARIABLE_REFERENCE);
1984 $1->appendChild(NTYPE($2, n_VARIABLE));
1985 $$ = NNEW(n_LEXICAL_VARIABLE_LIST);
1986 $$->appendChild($1);
1987 }
1988 ;
1989
1990 function_call:
1991 namespace_name '(' function_call_parameter_list ')' {
1992 $$ = NNEW(n_FUNCTION_CALL);
1993 $$->appendChild($1);
1994 $$->appendChild(NEXPAND($2, $3, $4));
1995 }
1996 | T_NAMESPACE T_NS_SEPARATOR namespace_name
1997 '(' function_call_parameter_list ')' {
1998 NMORE($3, $1);
1999 $$ = NNEW(n_FUNCTION_CALL);
2000 $$->appendChild($3);
2001 $$->appendChild(NEXPAND($4, $5, $6));
2002 }
2003 | T_NS_SEPARATOR namespace_name '(' function_call_parameter_list ')' {
2004 NMORE($2, $1);
2005 $$ = NNEW(n_FUNCTION_CALL);
2006 $$->appendChild($2);
2007 $$->appendChild(NEXPAND($3, $4, $5));
2008 }
2009 | class_name T_PAAMAYIM_NEKUDOTAYIM T_STRING
2010 '(' function_call_parameter_list ')' {
2011 $$ = NNEW(n_CLASS_STATIC_ACCESS);
2012 $$->appendChild($1);
2013 $$->appendChild(NTYPE($3, n_STRING));
2014
2015 $$ = NNEW(n_FUNCTION_CALL)->appendChild($$);
2016 $$->appendChild(NEXPAND($4, $5, $6));
2017 }
2018 | variable_class_name T_PAAMAYIM_NEKUDOTAYIM T_STRING
2019 '(' function_call_parameter_list ')' {
2020 $$ = NNEW(n_CLASS_STATIC_ACCESS);
2021 $$->appendChild($1);
2022 $$->appendChild(NTYPE($3, n_STRING));
2023
2024 $$ = NNEW(n_FUNCTION_CALL)->appendChild($$);
2025 $$->appendChild(NEXPAND($4, $5, $6));
2026 }
2027 | variable_class_name T_PAAMAYIM_NEKUDOTAYIM variable_without_objects
2028 '(' function_call_parameter_list ')' {
2029 $$ = NNEW(n_CLASS_STATIC_ACCESS);
2030 $$->appendChild($1);
2031 $$->appendChild(NTYPE($3, n_STRING));
2032
2033 $$ = NNEW(n_FUNCTION_CALL)->appendChild($$);
2034 $$->appendChild(NEXPAND($4, $5, $6));
2035 }
2036 | class_name T_PAAMAYIM_NEKUDOTAYIM variable_without_objects
2037 '(' function_call_parameter_list ')' {
2038 $$ = NNEW(n_CLASS_STATIC_ACCESS);
2039 $$->appendChild($1);
2040 $$->appendChild(NTYPE($3, n_STRING));
2041
2042 $$ = NNEW(n_FUNCTION_CALL)->appendChild($$);
2043 $$->appendChild(NEXPAND($4, $5, $6));
2044 }
2045 | variable_without_objects '(' function_call_parameter_list ')' {
2046 $$ = NNEW(n_FUNCTION_CALL);
2047 $$->appendChild($1);
2048 $$->appendChild(NEXPAND($2, $3, $4));
2049 }
2050 ;
2051
2052 class_name:
2053 T_STATIC {
2054 $$ = NTYPE($1, n_CLASS_NAME);
2055 }
2056 | namespace_name {
2057 $$ = NTYPE($1, n_CLASS_NAME);
2058 }
2059 | T_NAMESPACE T_NS_SEPARATOR namespace_name {
2060 NMORE($3, $1);
2061 $$ = NTYPE($3, n_CLASS_NAME);
2062 }
2063 | T_NS_SEPARATOR namespace_name {
2064 NMORE($2, $1);
2065 $$ = NTYPE($2, n_CLASS_NAME);
2066 }
2067 ;
2068
2069 fully_qualified_class_name:
2070 namespace_name {
2071 $$ = NTYPE($1, n_CLASS_NAME);
2072 }
2073 | T_NAMESPACE T_NS_SEPARATOR namespace_name {
2074 NMORE($3, $1);
2075 $$ = NTYPE($3, n_CLASS_NAME);
2076 }
2077 | T_NS_SEPARATOR namespace_name {
2078 NMORE($2, $1);
2079 $$ = NTYPE($2, n_CLASS_NAME);
2080 }
2081 ;
2082
2083 class_name_reference:
2084 class_name
2085 | dynamic_class_name_reference
2086 ;
2087
2088 dynamic_class_name_reference:
2089 base_variable
2090 T_OBJECT_OPERATOR
2091 object_property
2092 dynamic_class_name_variable_properties {
2093 $$ = NNEW(n_OBJECT_PROPERTY_ACCESS);
2094 $$->appendChild($1);
2095 $$->appendChild($3);
2096 for (xhpast::node_list_t::iterator ii = $4->children.begin();
2097 ii != $4->children.end();
2098 ++ii) {
2099
2100 $$ = NNEW(n_OBJECT_PROPERTY_ACCESS)->appendChild($$);
2101 $$->appendChild(*ii);
2102 }
2103 }
2104 | base_variable
2105 ;
2106
2107 dynamic_class_name_variable_properties:
2108 dynamic_class_name_variable_properties dynamic_class_name_variable_property {
2109 $$ = $1->appendChild($2);
2110 }
2111 | /* empty */ {
2112 $$ = NNEW(n_EMPTY);
2113 }
2114 ;
2115
2116 dynamic_class_name_variable_property:
2117 T_OBJECT_OPERATOR object_property {
2118 $$ = $2;
2119 }
2120 ;
2121
2122 exit_expr:
2123 /* empty */ {
2124 $$ = NNEW(n_EMPTY);
2125 }
2126 | '(' ')' {
2127 NSPAN($1, n_EMPTY, $2);
2128 $$ = $1;
2129 }
2130 | '(' expr ')' {
2131 NSPAN($1, n_PARENTHETICAL_EXPRESSION, $3);
2132 $1->appendChild($2);
2133 $$ = $1;
2134 }
2135 ;
2136
2137 ctor_arguments:
2138 /* empty */ {
2139 $$ = NNEW(n_EMPTY);
2140 }
2141 | '(' function_call_parameter_list ')' {
2142 $$ = NEXPAND($1, $2, $3);
2143 }
2144 ;
2145
2146 common_scalar:
2147 T_LNUMBER {
2148 $$ = NTYPE($1, n_NUMERIC_SCALAR);
2149 }
2150 | T_DNUMBER {
2151 $$ = NTYPE($1, n_NUMERIC_SCALAR);
2152 }
2153 | T_CONSTANT_ENCAPSED_STRING {
2154 $$ = NTYPE($1, n_STRING_SCALAR);
2155 }
2156 | T_LINE {
2157 $$ = NTYPE($1, n_MAGIC_SCALAR);
2158 }
2159 | T_FILE {
2160 $$ = NTYPE($1, n_MAGIC_SCALAR);
2161 }
2162 | T_DIR {
2163 $$ = NTYPE($1, n_MAGIC_SCALAR);
2164 }
2165 | T_CLASS_C {
2166 $$ = NTYPE($1, n_MAGIC_SCALAR);
2167 }
2168 | T_METHOD_C {
2169 $$ = NTYPE($1, n_MAGIC_SCALAR);
2170 }
2171 | T_TRAIT_C {
2172 $$ = NTYPE($1, n_MAGIC_SCALAR);
2173 }
2174 | T_FUNC_C {
2175 $$ = NTYPE($1, n_MAGIC_SCALAR);
2176 }
2177 | T_NS_C {
2178 $$ = NTYPE($1, n_MAGIC_SCALAR);
2179 }
2180 | T_HEREDOC {
2181 $$ = NTYPE($1, n_HEREDOC);
2182 }
2183 ;
2184
2185 static_scalar: /* compile-time evaluated scalars */
2186 common_scalar
2187 | namespace_name
2188 | T_NAMESPACE T_NS_SEPARATOR namespace_name {
2189 NMORE($3, $1);
2190 $$ = $3;
2191 }
2192 | T_NS_SEPARATOR namespace_name {
2193 NMORE($2, $1);
2194 $$ = $2;
2195 }
2196 | '+' static_scalar {
2197 $$ = NNEW(n_UNARY_PREFIX_EXPRESSION);
2198 $$->appendChild(NTYPE($1, n_OPERATOR));
2199 $$->appendChild($2);
2200 }
2201 | '-' static_scalar {
2202 $$ = NNEW(n_UNARY_PREFIX_EXPRESSION);
2203 $$->appendChild(NTYPE($1, n_OPERATOR));
2204 $$->appendChild($2);
2205 }
2206 | T_ARRAY '(' static_array_pair_list ')' {
2207 NTYPE($1, n_ARRAY_LITERAL);
2208 $1->appendChild(NEXPAND($2, $3, $4));
2209 $$ = $1;
2210 }
2211 | '[' static_array_pair_list ']' {
2212 NTYPE($1, n_ARRAY_LITERAL);
2213 $1->appendChild(NEXPAND($1, $2, $3));
2214 $$ = $1;
2215 }
2216 | static_class_constant
2217 ;
2218
2219 static_class_constant:
2220 class_name T_PAAMAYIM_NEKUDOTAYIM T_STRING {
2221 $$ = NNEW(n_CLASS_STATIC_ACCESS);
2222 $$->appendChild($1);
2223 $$->appendChild(NTYPE($3, n_STRING));
2224 }
2225 ;
2226
2227 scalar:
2228 T_STRING_VARNAME
2229 | class_constant
2230 | namespace_name
2231 | T_NAMESPACE T_NS_SEPARATOR namespace_name {
2232 $$ = NMORE($3, $1);
2233 }
2234 | T_NS_SEPARATOR namespace_name {
2235 $$ = NMORE($2, $1);
2236 }
2237 | common_scalar
2238 ;
2239
2240 static_array_pair_list:
2241 /* empty */ {
2242 $$ = NNEW(n_ARRAY_VALUE_LIST);
2243 }
2244 | non_empty_static_array_pair_list possible_comma {
2245 $$ = NMORE($1, $2);
2246 }
2247 ;
2248
2249 possible_comma:
2250 /* empty */ {
2251 $$ = NNEW(n_EMPTY);
2252 }
2253 | ','
2254 ;
2255
2256 non_empty_static_array_pair_list:
2257 non_empty_static_array_pair_list
2258 ','
2259 static_scalar
2260 T_DOUBLE_ARROW
2261 static_scalar {
2262 $$ = NNEW(n_ARRAY_VALUE);
2263 $$->appendChild($3);
2264 $$->appendChild($5);
2265
2266 $$ = $1->appendChild($$);
2267 }
2268 | non_empty_static_array_pair_list ',' static_scalar {
2269 $$ = NNEW(n_ARRAY_VALUE);
2270 $$->appendChild(NNEW(n_EMPTY));
2271 $$->appendChild($3);
2272
2273 $$ = $1->appendChild($$);
2274 }
2275 | static_scalar T_DOUBLE_ARROW static_scalar {
2276 $$ = NNEW(n_ARRAY_VALUE);
2277 $$->appendChild($1);
2278 $$->appendChild($3);
2279
2280 $$ = NNEW(n_ARRAY_VALUE_LIST)->appendChild($$);
2281 }
2282 | static_scalar {
2283 $$ = NNEW(n_ARRAY_VALUE);
2284 $$->appendChild(NNEW(n_EMPTY));
2285 $$->appendChild($1);
2286
2287 $$ = NNEW(n_ARRAY_VALUE_LIST)->appendChild($$);
2288 }
2289 ;
2290
2291 expr:
2292 r_variable
2293 | expr_without_variable
2294 ;
2295
2296 r_variable:
2297 variable
2298 ;
2299
2300 w_variable:
2301 variable
2302 ;
2303
2304 rw_variable:
2305 variable
2306 ;
2307
2308 variable:
2309 base_variable_with_function_calls
2310 T_OBJECT_OPERATOR
2311 object_property method_or_not
2312 variable_properties {
2313 $$ = NNEW(n_OBJECT_PROPERTY_ACCESS);
2314 $$->appendChild($1);
2315 $$->appendChild($3);
2316
2317 if ($4->type != n_EMPTY) {
2318 $$ = NNEW(n_METHOD_CALL)->appendChild($$);
2319 $$->appendChild($4);
2320 }
2321
2322 for (xhpast::node_list_t::iterator ii = $5->children.begin();
2323 ii != $5->children.end();
2324 ++ii) {
2325
2326 if ((*ii)->type == n_CALL_PARAMETER_LIST) {
2327 $$ = NNEW(n_METHOD_CALL)->appendChild($$);
2328 $$->appendChild((*ii));
2329 } else {
2330 $$ = NNEW(n_OBJECT_PROPERTY_ACCESS)->appendChild($$);
2331 $$->appendChild((*ii));
2332 }
2333 }
2334 }
2335 | base_variable_with_function_calls
2336 ;
2337
2338 variable_properties:
2339 variable_properties variable_property {
2340 $$ = $1->appendChildren($2);
2341 }
2342 | /* empty */ {
2343 $$ = NNEW(n_EMPTY);
2344 }
2345 ;
2346
2347 variable_property:
2348 T_OBJECT_OPERATOR object_property method_or_not {
2349 $$ = NNEW(n_EMPTY);
2350 $$->appendChild($2);
2351 if ($3->type != n_EMPTY) {
2352 $$->appendChild($3);
2353 }
2354 }
2355 ;
2356
2357 array_method_dereference:
2358 array_method_dereference '[' dim_offset ']' {
2359 $$ = NNEW(n_INDEX_ACCESS);
2360 $$->appendChild($1);
2361 $$->appendChild($3);
2362 NMORE($$, $4);
2363 }
2364 | method '[' dim_offset ']' {
2365 $$ = NNEW(n_INDEX_ACCESS);
2366 $$->appendChild($1);
2367 $$->appendChild($3);
2368 NMORE($$, $4);
2369 }
2370 ;
2371
2372 method:
2373 '(' function_call_parameter_list ')' {
2374 $$ = NEXPAND($1, $2, $3);
2375 }
2376 ;
2377
2378 method_or_not:
2379 method
2380 | array_method_dereference
2381 | /* empty */ {
2382 $$ = NNEW(n_EMPTY);
2383 }
2384 ;
2385
2386 variable_without_objects:
2387 reference_variable
2388 | simple_indirect_reference reference_variable {
2389 xhpast::Node *last = $1;
2390 NMORE($1, $2);
2391 while (last->firstChild() &&
2392 last->firstChild()->type == n_VARIABLE_VARIABLE) {
2393 NMORE(last, $2);
2394 last = last->firstChild();
2395 }
2396 last->appendChild($2);
2397
2398 $$ = $1;
2399 }
2400 ;
2401
2402 static_member:
2403 class_name T_PAAMAYIM_NEKUDOTAYIM variable_without_objects {
2404 $$ = NNEW(n_CLASS_STATIC_ACCESS);
2405 $$->appendChild($1);
2406 $$->appendChild($3);
2407 }
2408 | variable_class_name T_PAAMAYIM_NEKUDOTAYIM variable_without_objects {
2409 $$ = NNEW(n_CLASS_STATIC_ACCESS);
2410 $$->appendChild($1);
2411 $$->appendChild($3);
2412 }
2413 ;
2414
2415 variable_class_name:
2416 reference_variable
2417 ;
2418
2419 array_function_dereference:
2420 array_function_dereference '[' dim_offset ']' {
2421 $$ = NNEW(n_INDEX_ACCESS);
2422 $$->appendChild($1);
2423 $$->appendChild($3);
2424 NMORE($$, $4);
2425 }
2426 | function_call '[' dim_offset ']' {
2427 $$ = NNEW(n_INDEX_ACCESS);
2428 $$->appendChild($1);
2429 $$->appendChild($3);
2430 NMORE($$, $4);
2431 }
2432 ;
2433
2434 base_variable_with_function_calls:
2435 base_variable
2436 | array_function_dereference
2437 | function_call
2438 ;
2439
2440 base_variable:
2441 reference_variable
2442 | '(' new_expr ')' {
2443 $$ = NEXPAND($1, $2, $3);
2444 }
2445 | simple_indirect_reference reference_variable {
2446 xhpast::Node *last = $1;
2447 NMORE($1, $2);
2448 while (last->firstChild() &&
2449 last->firstChild()->type == n_VARIABLE_VARIABLE) {
2450 NMORE(last, $2);
2451 last = last->firstChild();
2452 }
2453 last->appendChild($2);
2454
2455 $$ = $1;
2456 }
2457 | static_member
2458 ;
2459
2460 reference_variable:
2461 reference_variable '[' dim_offset ']' {
2462 $$ = NNEW(n_INDEX_ACCESS);
2463 $$->appendChild($1);
2464 $$->appendChild($3);
2465 NMORE($$, $4);
2466 }
2467 | reference_variable '{' expr '}' {
2468 $$ = NNEW(n_INDEX_ACCESS);
2469 $$->appendChild($1);
2470 $$->appendChild($3);
2471 NMORE($$, $4);
2472 }
2473 | compound_variable
2474 ;
2475
2476 compound_variable:
2477 T_VARIABLE {
2478 NTYPE($1, n_VARIABLE);
2479 }
2480 | '$' '{' expr '}' {
2481 NSPAN($1, n_VARIABLE_EXPRESSION, $4);
2482 $1->appendChild($3);
2483 $$ = $1;
2484 }
2485 ;
2486
2487 dim_offset:
2488 /* empty */ {
2489 $$ = NNEW(n_EMPTY);
2490 }
2491 | expr {
2492 $$ = $1;
2493 }
2494 ;
2495
2496 object_property:
2497 object_dim_list
2498 | variable_without_objects
2499 ;
2500
2501 object_dim_list:
2502 object_dim_list '[' dim_offset ']' {
2503 $$ = NNEW(n_INDEX_ACCESS);
2504 $$->appendChild($1);
2505 $$->appendChild($3);
2506 NMORE($$, $4);
2507 }
2508 | object_dim_list '{' expr '}' {
2509 $$ = NNEW(n_INDEX_ACCESS);
2510 $$->appendChild($1);
2511 $$->appendChild($3);
2512 NMORE($$, $4);
2513 }
2514 | variable_name
2515 ;
2516
2517 variable_name:
2518 T_STRING {
2519 NTYPE($1, n_STRING);
2520 $$ = $1;
2521 }
2522 | '{' expr '}' {
2523 $$ = NEXPAND($1, $2, $3);
2524 }
2525 ;
2526
2527 simple_indirect_reference:
2528 '$' {
2529 $$ = NTYPE($1, n_VARIABLE_VARIABLE);
2530 }
2531 | simple_indirect_reference '$' {
2532 $2 = NTYPE($2, n_VARIABLE_VARIABLE);
2533
2534 xhpast::Node *last = $1;
2535 while (last->firstChild() &&
2536 last->firstChild()->type == n_VARIABLE_VARIABLE) {
2537 last = last->firstChild();
2538 }
2539 last->appendChild($2);
2540
2541 $$ = $1;
2542 }
2543 ;
2544
2545 assignment_list:
2546 assignment_list ',' assignment_list_element {
2547 $$ = $1->appendChild($3);
2548 }
2549 | assignment_list_element {
2550 $$ = NNEW(n_ASSIGNMENT_LIST);
2551 $$->appendChild($1);
2552 }
2553 ;
2554
2555 assignment_list_element:
2556 variable
2557 | T_LIST '(' assignment_list ')' {
2558 $$ = NNEW(n_LIST);
2559 $$->appendChild(NEXPAND($2, $3, $4));
2560 }
2561 | /* empty */ {
2562 $$ = NNEW(n_EMPTY);
2563 }
2564 ;
2565
2566 array_pair_list:
2567 /* empty */ {
2568 $$ = NNEW(n_ARRAY_VALUE_LIST);
2569 }
2570 | non_empty_array_pair_list possible_comma {
2571 $$ = NMORE($1, $2);
2572 }
2573 ;
2574
2575 non_empty_array_pair_list:
2576 non_empty_array_pair_list ',' expr T_DOUBLE_ARROW expr {
2577 $$ = NNEW(n_ARRAY_VALUE);
2578 $$->appendChild($3);
2579 $$->appendChild($5);
2580
2581 $$ = $1->appendChild($$);
2582 }
2583 | non_empty_array_pair_list ',' expr {
2584 $$ = NNEW(n_ARRAY_VALUE);
2585 $$->appendChild(NNEW(n_EMPTY));
2586 $$->appendChild($3);
2587
2588 $$ = $1->appendChild($$);
2589 }
2590 | expr T_DOUBLE_ARROW expr {
2591 $$ = NNEW(n_ARRAY_VALUE);
2592 $$->appendChild($1);
2593 $$->appendChild($3);
2594
2595 $$ = NNEW(n_ARRAY_VALUE_LIST)->appendChild($$);
2596 }
2597 | expr {
2598 $$ = NNEW(n_ARRAY_VALUE);
2599 $$->appendChild(NNEW(n_EMPTY));
2600 $$->appendChild($1);
2601
2602 $$ = NNEW(n_ARRAY_VALUE_LIST)->appendChild($$);
2603 }
2604 | non_empty_array_pair_list ',' expr T_DOUBLE_ARROW '&' w_variable {
2605 $$ = NNEW(n_ARRAY_VALUE);
2606 $$->appendChild($3);
2607 $$->appendChild(NTYPE($5, n_VARIABLE_REFERENCE)->appendChild($6));
2608
2609 $$ = $1->appendChild($$);
2610 }
2611 | non_empty_array_pair_list ',' '&' w_variable {
2612 $$ = NNEW(n_ARRAY_VALUE);
2613 $$->appendChild(NNEW(n_EMPTY));
2614 $$->appendChild(NTYPE($3, n_VARIABLE_REFERENCE)->appendChild($4));
2615
2616 $$ = $1->appendChild($$);
2617 }
2618 | expr T_DOUBLE_ARROW '&' w_variable {
2619 $$ = NNEW(n_ARRAY_VALUE);
2620 $$->appendChild($1);
2621 $$->appendChild(NTYPE($3, n_VARIABLE_REFERENCE)->appendChild($4));
2622
2623 $$ = NNEW(n_ARRAY_VALUE_LIST)->appendChild($$);
2624 }
2625 | '&' w_variable {
2626 $$ = NNEW(n_ARRAY_VALUE);
2627 $$->appendChild(NNEW(n_EMPTY));
2628 $$->appendChild(NTYPE($1, n_VARIABLE_REFERENCE)->appendChild($2));
2629
2630 $$ = NNEW(n_ARRAY_VALUE_LIST)->appendChild($$);
2631 }
2632 ;
2633
2634 internal_functions_in_yacc:
2635 T_ISSET '(' isset_variables ')' {
2636 NTYPE($1, n_SYMBOL_NAME);
2637
2638 NSPAN($2, n_CALL_PARAMETER_LIST, $4);
2639 $2->appendChildren($3);
2640
2641 $$ = NNEW(n_FUNCTION_CALL);
2642 $$->appendChild($1);
2643 $$->appendChild($2);
2644 }
2645 | T_EMPTY '(' variable ')' {
2646 NTYPE($1, n_SYMBOL_NAME);
2647
2648 NSPAN($2, n_CALL_PARAMETER_LIST, $4);
2649 $2->appendChild($3);
2650
2651 $$ = NNEW(n_FUNCTION_CALL);
2652 $$->appendChild($1);
2653 $$->appendChild($2);
2654 }
2655 | T_INCLUDE expr {
2656 $$ = NTYPE($1, n_INCLUDE_FILE)->appendChild($2);
2657 }
2658 | T_INCLUDE_ONCE expr {
2659 $$ = NTYPE($1, n_INCLUDE_FILE)->appendChild($2);
2660 }
2661 | T_EVAL '(' expr ')' {
2662 NTYPE($1, n_SYMBOL_NAME);
2663
2664 NSPAN($2, n_CALL_PARAMETER_LIST, $4);
2665 $2->appendChild($3);
2666
2667 $$ = NNEW(n_FUNCTION_CALL);
2668 $$->appendChild($1);
2669 $$->appendChild($2);
2670 }
2671 | T_REQUIRE expr {
2672 $$ = NTYPE($1, n_INCLUDE_FILE)->appendChild($2);
2673 }
2674 | T_REQUIRE_ONCE expr {
2675 $$ = NTYPE($1, n_INCLUDE_FILE)->appendChild($2);
2676 }
2677 ;
2678
2679 isset_variables:
2680 variable {
2681 $$ = NNEW(n_EMPTY);
2682 $$->appendChild($1);
2683 }
2684 | isset_variables ',' variable {
2685 $$ = $1->appendChild($3);
2686 }
2687 ;
2688
2689 parenthesis_expr:
2690 '(' expr ')' {
2691 NSPAN($1, n_PARENTHETICAL_EXPRESSION, $3);
2692 $1->appendChild($2);
2693 $$ = $1;
2694 }
2695 | '(' yield_expr ')' {
2696 $$ = NEXPAND($1, $2, $3);
2697 }
2698 ;
2699
2700 combined_scalar_offset:
2701 combined_scalar '[' dim_offset ']' {
2702 $$ = NNEW(n_INDEX_ACCESS);
2703 $$->appendChild($1);
2704 $$->appendChild($3);
2705 NMORE($$, $4);
2706 }
2707 | combined_scalar_offset '[' dim_offset ']' {
2708 $$ = NNEW(n_INDEX_ACCESS);
2709 $$->appendChild($1);
2710 $$->appendChild($3);
2711 NMORE($$, $4);
2712 }
2713 | T_CONSTANT_ENCAPSED_STRING '[' dim_offset ']' {
2714 $$ = NNEW(n_INDEX_ACCESS);
2715 $$->appendChild(NTYPE($1, n_STRING_SCALAR));
2716 $$->appendChild($3);
2717 NMORE($$, $4);
2718 }
2719 | class_constant '[' dim_offset ']' {
2720 $$ = NNEW(n_INDEX_ACCESS);
2721 $$->appendChild($1);
2722 $$->appendChild($3);
2723 NMORE($$, $4);
2724 }
2725 | T_STRING '[' dim_offset ']' {
2726 $$ = NNEW(n_INDEX_ACCESS);
2727 $$->appendChild(NTYPE($1, n_STRING));
2728 $$->appendChild($3);
2729 NMORE($$, $4);
2730 }
2731 ;
2732
2733 combined_scalar:
2734 T_ARRAY '(' array_pair_list ')' {
2735 NTYPE($1, n_ARRAY_LITERAL);
2736 $1->appendChild(NEXPAND($2, $3, $4));
2737 $$ = $1;
2738 }
2739 | '[' array_pair_list ']' {
2740 NTYPE($1, n_ARRAY_LITERAL);
2741 $1->appendChild(NEXPAND($1, $2, $3));
2742 $$ = $1;
2743 }
2744 ;
2745
2746 new_expr:
2747 T_NEW class_name_reference ctor_arguments {
2748 NTYPE($1, n_NEW);
2749 $1->appendChild($2);
2750 $1->appendChild($3);
2751 $$ = $1;
2752 }
2753 | T_NEW T_CLASS ctor_arguments extends_from implements_list
2754 '{' class_statement_list '}' {
2755 $$ = NNEW(n_CLASS_DECLARATION);
2756 $$->appendChild(NNEW(n_EMPTY));
2757 $$->appendChild(NNEW(n_EMPTY));
2758 $$->appendChild($4);
2759 $$->appendChild($5);
2760 $$->appendChild(NEXPAND($6, $7, $8));
2761 NMORE($$, $8);
2762
2763 NTYPE($1, n_NEW);
2764 $1->appendChild($$);
2765 $1->appendChild($3);
2766 $$ = $1;
2767 }
2768 ;
2769
2770 class_constant:
2771 class_name T_PAAMAYIM_NEKUDOTAYIM T_STRING {
2772 $$ = NNEW(n_CLASS_STATIC_ACCESS);
2773 $$->appendChild($1);
2774 $$->appendChild(NTYPE($3, n_STRING));
2775 }
2776 | variable_class_name T_PAAMAYIM_NEKUDOTAYIM T_STRING {
2777 $$ = NNEW(n_CLASS_STATIC_ACCESS);
2778 $$->appendChild($1);
2779 $$->appendChild(NTYPE($3, n_STRING));
2780 }
2781 ;
2782
2783 %%
2784
2785 const char* yytokname(int tok) {
2786 if (tok < 255) {
2787 return NULL;
2788 }
2789 return yytname[YYTRANSLATE(tok)];
2790 }
2791