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