Mercurial > hg > isophonics-drupal-site

comparison vendor/nikic/php-parser/grammar/php5.y @ 0:4c8ae668cc8c

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Initial import (non-working)
author Chris Cannam
date Wed, 29 Nov 2017 16:09:58 +0000
parents
children 5fb285c0d0e3
comparison
equal deleted inserted replaced
-1:000000000000 0:4c8ae668cc8c
1 %pure_parser
2 %expect 6
3
4 %tokens
5
6 %%
7
8 start:
9 top_statement_list { $$ = $this->handleNamespaces($1); }
10 ;
11
12 top_statement_list_ex:
13 top_statement_list_ex top_statement { pushNormalizing($1, $2); }
14 | /* empty */ { init(); }
15 ;
16
17 top_statement_list:
18 top_statement_list_ex
19 { makeNop($nop, $this->lookaheadStartAttributes);
20 if ($nop !== null) { $1[] = $nop; } $$ = $1; }
21 ;
22
23 reserved_non_modifiers:
24 T_INCLUDE | T_INCLUDE_ONCE | T_EVAL | T_REQUIRE | T_REQUIRE_ONCE | T_LOGICAL_OR | T_LOGICAL_XOR | T_LOGICAL_AND
25 | T_INSTANCEOF | T_NEW | T_CLONE | T_EXIT | T_IF | T_ELSEIF | T_ELSE | T_ENDIF | T_ECHO | T_DO | T_WHILE
26 | T_ENDWHILE | T_FOR | T_ENDFOR | T_FOREACH | T_ENDFOREACH | T_DECLARE | T_ENDDECLARE | T_AS | T_TRY | T_CATCH
27 | T_FINALLY | T_THROW | T_USE | T_INSTEADOF | T_GLOBAL | T_VAR | T_UNSET | T_ISSET | T_EMPTY | T_CONTINUE | T_GOTO
28 | T_FUNCTION | T_CONST | T_RETURN | T_PRINT | T_YIELD | T_LIST | T_SWITCH | T_ENDSWITCH | T_CASE | T_DEFAULT
29 | T_BREAK | T_ARRAY | T_CALLABLE | T_EXTENDS | T_IMPLEMENTS | T_NAMESPACE | T_TRAIT | T_INTERFACE | T_CLASS
30 | T_CLASS_C | T_TRAIT_C | T_FUNC_C | T_METHOD_C | T_LINE | T_FILE | T_DIR | T_NS_C | T_HALT_COMPILER
31 ;
32
33 semi_reserved:
34 reserved_non_modifiers
35 | T_STATIC | T_ABSTRACT | T_FINAL | T_PRIVATE | T_PROTECTED | T_PUBLIC
36 ;
37
38 identifier:
39 T_STRING { $$ = $1; }
40 | semi_reserved { $$ = $1; }
41 ;
42
43 namespace_name_parts:
44 T_STRING { init($1); }
45 | namespace_name_parts T_NS_SEPARATOR T_STRING { push($1, $3); }
46 ;
47
48 namespace_name:
49 namespace_name_parts { $$ = Name[$1]; }
50 ;
51
52 top_statement:
53 statement { $$ = $1; }
54 | function_declaration_statement { $$ = $1; }
55 | class_declaration_statement { $$ = $1; }
56 | T_HALT_COMPILER
57 { $$ = Stmt\HaltCompiler[$this->lexer->handleHaltCompiler()]; }
58 | T_NAMESPACE namespace_name ';'
59 { $$ = Stmt\Namespace_[$2, null];
60 $$->setAttribute('kind', Stmt\Namespace_::KIND_SEMICOLON);
61 $this->checkNamespace($$); }
62 | T_NAMESPACE namespace_name '{' top_statement_list '}'
63 { $$ = Stmt\Namespace_[$2, $4];
64 $$->setAttribute('kind', Stmt\Namespace_::KIND_BRACED);
65 $this->checkNamespace($$); }
66 | T_NAMESPACE '{' top_statement_list '}'
67 { $$ = Stmt\Namespace_[null, $3];
68 $$->setAttribute('kind', Stmt\Namespace_::KIND_BRACED);
69 $this->checkNamespace($$); }
70 | T_USE use_declarations ';' { $$ = Stmt\Use_[$2, Stmt\Use_::TYPE_NORMAL]; }
71 | T_USE use_type use_declarations ';' { $$ = Stmt\Use_[$3, $2]; }
72 | group_use_declaration ';' { $$ = $1; }
73 | T_CONST constant_declaration_list ';' { $$ = Stmt\Const_[$2]; }
74 ;
75
76 use_type:
77 T_FUNCTION { $$ = Stmt\Use_::TYPE_FUNCTION; }
78 | T_CONST { $$ = Stmt\Use_::TYPE_CONSTANT; }
79 ;
80
81 /* Using namespace_name_parts here to avoid s/r conflict on T_NS_SEPARATOR */
82 group_use_declaration:
83 T_USE use_type namespace_name_parts T_NS_SEPARATOR '{' unprefixed_use_declarations '}'
84 { $$ = Stmt\GroupUse[new Name($3, stackAttributes(#3)), $6, $2]; }
85 | T_USE use_type T_NS_SEPARATOR namespace_name_parts T_NS_SEPARATOR '{' unprefixed_use_declarations '}'
86 { $$ = Stmt\GroupUse[new Name($4, stackAttributes(#4)), $7, $2]; }
87 | T_USE namespace_name_parts T_NS_SEPARATOR '{' inline_use_declarations '}'
88 { $$ = Stmt\GroupUse[new Name($2, stackAttributes(#2)), $5, Stmt\Use_::TYPE_UNKNOWN]; }
89 | T_USE T_NS_SEPARATOR namespace_name_parts T_NS_SEPARATOR '{' inline_use_declarations '}'
90 { $$ = Stmt\GroupUse[new Name($3, stackAttributes(#3)), $6, Stmt\Use_::TYPE_UNKNOWN]; }
91 ;
92
93 unprefixed_use_declarations:
94 unprefixed_use_declarations ',' unprefixed_use_declaration
95 { push($1, $3); }
96 | unprefixed_use_declaration { init($1); }
97 ;
98
99 use_declarations:
100 use_declarations ',' use_declaration { push($1, $3); }
101 | use_declaration { init($1); }
102 ;
103
104 inline_use_declarations:
105 inline_use_declarations ',' inline_use_declaration { push($1, $3); }
106 | inline_use_declaration { init($1); }
107 ;
108
109 unprefixed_use_declaration:
110 namespace_name
111 { $$ = Stmt\UseUse[$1, null, Stmt\Use_::TYPE_UNKNOWN]; $this->checkUseUse($$, #1); }
112 | namespace_name T_AS T_STRING
113 { $$ = Stmt\UseUse[$1, $3, Stmt\Use_::TYPE_UNKNOWN]; $this->checkUseUse($$, #3); }
114 ;
115
116 use_declaration:
117 unprefixed_use_declaration { $$ = $1; }
118 | T_NS_SEPARATOR unprefixed_use_declaration { $$ = $2; }
119 ;
120
121 inline_use_declaration:
122 unprefixed_use_declaration { $$ = $1; $$->type = Stmt\Use_::TYPE_NORMAL; }
123 | use_type unprefixed_use_declaration { $$ = $2; $$->type = $1; }
124 ;
125
126 constant_declaration_list:
127 constant_declaration_list ',' constant_declaration { push($1, $3); }
128 | constant_declaration { init($1); }
129 ;
130
131 constant_declaration:
132 T_STRING '=' static_scalar { $$ = Node\Const_[$1, $3]; }
133 ;
134
135 class_const_list:
136 class_const_list ',' class_const { push($1, $3); }
137 | class_const { init($1); }
138 ;
139
140 class_const:
141 identifier '=' static_scalar { $$ = Node\Const_[$1, $3]; }
142 ;
143
144 inner_statement_list_ex:
145 inner_statement_list_ex inner_statement { pushNormalizing($1, $2); }
146 | /* empty */ { init(); }
147 ;
148
149 inner_statement_list:
150 inner_statement_list_ex
151 { makeNop($nop, $this->lookaheadStartAttributes);
152 if ($nop !== null) { $1[] = $nop; } $$ = $1; }
153 ;
154
155 inner_statement:
156 statement { $$ = $1; }
157 | function_declaration_statement { $$ = $1; }
158 | class_declaration_statement { $$ = $1; }
159 | T_HALT_COMPILER
160 { throw new Error('__HALT_COMPILER() can only be used from the outermost scope', attributes()); }
161 ;
162
163 non_empty_statement:
164 '{' inner_statement_list '}'
165 {
166 if ($2) {
167 $$ = $2; prependLeadingComments($$);
168 } else {
169 makeNop($$, $this->startAttributeStack[#1]);
170 if (null === $$) { $$ = array(); }
171 }
172 }
173 | T_IF parentheses_expr statement elseif_list else_single
174 { $$ = Stmt\If_[$2, ['stmts' => toArray($3), 'elseifs' => $4, 'else' => $5]]; }
175 | T_IF parentheses_expr ':' inner_statement_list new_elseif_list new_else_single T_ENDIF ';'
176 { $$ = Stmt\If_[$2, ['stmts' => $4, 'elseifs' => $5, 'else' => $6]]; }
177 | T_WHILE parentheses_expr while_statement { $$ = Stmt\While_[$2, $3]; }
178 | T_DO statement T_WHILE parentheses_expr ';' { $$ = Stmt\Do_ [$4, toArray($2)]; }
179 | T_FOR '(' for_expr ';' for_expr ';' for_expr ')' for_statement
180 { $$ = Stmt\For_[['init' => $3, 'cond' => $5, 'loop' => $7, 'stmts' => $9]]; }
181 | T_SWITCH parentheses_expr switch_case_list { $$ = Stmt\Switch_[$2, $3]; }
182 | T_BREAK ';' { $$ = Stmt\Break_[null]; }
183 | T_BREAK expr ';' { $$ = Stmt\Break_[$2]; }
184 | T_CONTINUE ';' { $$ = Stmt\Continue_[null]; }
185 | T_CONTINUE expr ';' { $$ = Stmt\Continue_[$2]; }
186 | T_RETURN ';' { $$ = Stmt\Return_[null]; }
187 | T_RETURN expr ';' { $$ = Stmt\Return_[$2]; }
188 | yield_expr ';' { $$ = $1; }
189 | T_GLOBAL global_var_list ';' { $$ = Stmt\Global_[$2]; }
190 | T_STATIC static_var_list ';' { $$ = Stmt\Static_[$2]; }
191 | T_ECHO expr_list ';' { $$ = Stmt\Echo_[$2]; }
192 | T_INLINE_HTML { $$ = Stmt\InlineHTML[$1]; }
193 | expr ';' { $$ = $1; }
194 | T_UNSET '(' variables_list ')' ';' { $$ = Stmt\Unset_[$3]; }
195 | T_FOREACH '(' expr T_AS foreach_variable ')' foreach_statement
196 { $$ = Stmt\Foreach_[$3, $5[0], ['keyVar' => null, 'byRef' => $5[1], 'stmts' => $7]]; }
197 | T_FOREACH '(' expr T_AS variable T_DOUBLE_ARROW foreach_variable ')' foreach_statement
198 { $$ = Stmt\Foreach_[$3, $7[0], ['keyVar' => $5, 'byRef' => $7[1], 'stmts' => $9]]; }
199 | T_DECLARE '(' declare_list ')' declare_statement { $$ = Stmt\Declare_[$3, $5]; }
200 | T_TRY '{' inner_statement_list '}' catches optional_finally
201 { $$ = Stmt\TryCatch[$3, $5, $6]; $this->checkTryCatch($$); }
202 | T_THROW expr ';' { $$ = Stmt\Throw_[$2]; }
203 | T_GOTO T_STRING ';' { $$ = Stmt\Goto_[$2]; }
204 | T_STRING ':' { $$ = Stmt\Label[$1]; }
205 | expr error { $$ = $1; }
206 | error { $$ = array(); /* means: no statement */ }
207 ;
208
209 statement:
210 non_empty_statement { $$ = $1; }
211 | ';'
212 { makeNop($$, $this->startAttributeStack[#1]);
213 if ($$ === null) $$ = array(); /* means: no statement */ }
214 ;
215
216 catches:
217 /* empty */ { init(); }
218 | catches catch { push($1, $2); }
219 ;
220
221 catch:
222 T_CATCH '(' name T_VARIABLE ')' '{' inner_statement_list '}'
223 { $$ = Stmt\Catch_[array($3), parseVar($4), $7]; }
224 ;
225
226 optional_finally:
227 /* empty */ { $$ = null; }
228 | T_FINALLY '{' inner_statement_list '}' { $$ = Stmt\Finally_[$3]; }
229 ;
230
231 variables_list:
232 variable { init($1); }
233 | variables_list ',' variable { push($1, $3); }
234 ;
235
236 optional_ref:
237 /* empty */ { $$ = false; }
238 | '&' { $$ = true; }
239 ;
240
241 optional_ellipsis:
242 /* empty */ { $$ = false; }
243 | T_ELLIPSIS { $$ = true; }
244 ;
245
246 function_declaration_statement:
247 T_FUNCTION optional_ref T_STRING '(' parameter_list ')' optional_return_type '{' inner_statement_list '}'
248 { $$ = Stmt\Function_[$3, ['byRef' => $2, 'params' => $5, 'returnType' => $7, 'stmts' => $9]]; }
249 ;
250
251 class_declaration_statement:
252 class_entry_type T_STRING extends_from implements_list '{' class_statement_list '}'
253 { $$ = Stmt\Class_[$2, ['type' => $1, 'extends' => $3, 'implements' => $4, 'stmts' => $6]];
254 $this->checkClass($$, #2); }
255 | T_INTERFACE T_STRING interface_extends_list '{' class_statement_list '}'
256 { $$ = Stmt\Interface_[$2, ['extends' => $3, 'stmts' => $5]];
257 $this->checkInterface($$, #2); }
258 | T_TRAIT T_STRING '{' class_statement_list '}'
259 { $$ = Stmt\Trait_[$2, ['stmts' => $4]]; }
260 ;
261
262 class_entry_type:
263 T_CLASS { $$ = 0; }
264 | T_ABSTRACT T_CLASS { $$ = Stmt\Class_::MODIFIER_ABSTRACT; }
265 | T_FINAL T_CLASS { $$ = Stmt\Class_::MODIFIER_FINAL; }
266 ;
267
268 extends_from:
269 /* empty */ { $$ = null; }
270 | T_EXTENDS class_name { $$ = $2; }
271 ;
272
273 interface_extends_list:
274 /* empty */ { $$ = array(); }
275 | T_EXTENDS class_name_list { $$ = $2; }
276 ;
277
278 implements_list:
279 /* empty */ { $$ = array(); }
280 | T_IMPLEMENTS class_name_list { $$ = $2; }
281 ;
282
283 class_name_list:
284 class_name { init($1); }
285 | class_name_list ',' class_name { push($1, $3); }
286 ;
287
288 for_statement:
289 statement { $$ = toArray($1); }
290 | ':' inner_statement_list T_ENDFOR ';' { $$ = $2; }
291 ;
292
293 foreach_statement:
294 statement { $$ = toArray($1); }
295 | ':' inner_statement_list T_ENDFOREACH ';' { $$ = $2; }
296 ;
297
298 declare_statement:
299 non_empty_statement { $$ = toArray($1); }
300 | ';' { $$ = null; }
301 | ':' inner_statement_list T_ENDDECLARE ';' { $$ = $2; }
302 ;
303
304 declare_list:
305 declare_list_element { init($1); }
306 | declare_list ',' declare_list_element { push($1, $3); }
307 ;
308
309 declare_list_element:
310 T_STRING '=' static_scalar { $$ = Stmt\DeclareDeclare[$1, $3]; }
311 ;
312
313 switch_case_list:
314 '{' case_list '}' { $$ = $2; }
315 | '{' ';' case_list '}' { $$ = $3; }
316 | ':' case_list T_ENDSWITCH ';' { $$ = $2; }
317 | ':' ';' case_list T_ENDSWITCH ';' { $$ = $3; }
318 ;
319
320 case_list:
321 /* empty */ { init(); }
322 | case_list case { push($1, $2); }
323 ;
324
325 case:
326 T_CASE expr case_separator inner_statement_list { $$ = Stmt\Case_[$2, $4]; }
327 | T_DEFAULT case_separator inner_statement_list { $$ = Stmt\Case_[null, $3]; }
328 ;
329
330 case_separator:
331 ':'
332 | ';'
333 ;
334
335 while_statement:
336 statement { $$ = toArray($1); }
337 | ':' inner_statement_list T_ENDWHILE ';' { $$ = $2; }
338 ;
339
340 elseif_list:
341 /* empty */ { init(); }
342 | elseif_list elseif { push($1, $2); }
343 ;
344
345 elseif:
346 T_ELSEIF parentheses_expr statement { $$ = Stmt\ElseIf_[$2, toArray($3)]; }
347 ;
348
349 new_elseif_list:
350 /* empty */ { init(); }
351 | new_elseif_list new_elseif { push($1, $2); }
352 ;
353
354 new_elseif:
355 T_ELSEIF parentheses_expr ':' inner_statement_list { $$ = Stmt\ElseIf_[$2, $4]; }
356 ;
357
358 else_single:
359 /* empty */ { $$ = null; }
360 | T_ELSE statement { $$ = Stmt\Else_[toArray($2)]; }
361 ;
362
363 new_else_single:
364 /* empty */ { $$ = null; }
365 | T_ELSE ':' inner_statement_list { $$ = Stmt\Else_[$3]; }
366 ;
367
368 foreach_variable:
369 variable { $$ = array($1, false); }
370 | '&' variable { $$ = array($2, true); }
371 | list_expr { $$ = array($1, false); }
372 ;
373
374 parameter_list:
375 non_empty_parameter_list { $$ = $1; }
376 | /* empty */ { $$ = array(); }
377 ;
378
379 non_empty_parameter_list:
380 parameter { init($1); }
381 | non_empty_parameter_list ',' parameter { push($1, $3); }
382 ;
383
384 parameter:
385 optional_param_type optional_ref optional_ellipsis T_VARIABLE
386 { $$ = Node\Param[parseVar($4), null, $1, $2, $3]; $this->checkParam($$); }
387 | optional_param_type optional_ref optional_ellipsis T_VARIABLE '=' static_scalar
388 { $$ = Node\Param[parseVar($4), $6, $1, $2, $3]; $this->checkParam($$); }
389 ;
390
391 type:
392 name { $$ = $1; }
393 | T_ARRAY { $$ = 'array'; }
394 | T_CALLABLE { $$ = 'callable'; }
395 ;
396
397 optional_param_type:
398 /* empty */ { $$ = null; }
399 | type { $$ = $1; }
400 ;
401
402 optional_return_type:
403 /* empty */ { $$ = null; }
404 | ':' type { $$ = $2; }
405 ;
406
407 argument_list:
408 '(' ')' { $$ = array(); }
409 | '(' non_empty_argument_list ')' { $$ = $2; }
410 | '(' yield_expr ')' { $$ = array(Node\Arg[$2, false, false]); }
411 ;
412
413 non_empty_argument_list:
414 argument { init($1); }
415 | non_empty_argument_list ',' argument { push($1, $3); }
416 ;
417
418 argument:
419 expr { $$ = Node\Arg[$1, false, false]; }
420 | '&' variable { $$ = Node\Arg[$2, true, false]; }
421 | T_ELLIPSIS expr { $$ = Node\Arg[$2, false, true]; }
422 ;
423
424 global_var_list:
425 global_var_list ',' global_var { push($1, $3); }
426 | global_var { init($1); }
427 ;
428
429 global_var:
430 T_VARIABLE { $$ = Expr\Variable[parseVar($1)]; }
431 | '$' variable { $$ = Expr\Variable[$2]; }
432 | '$' '{' expr '}' { $$ = Expr\Variable[$3]; }
433 ;
434
435 static_var_list:
436 static_var_list ',' static_var { push($1, $3); }
437 | static_var { init($1); }
438 ;
439
440 static_var:
441 T_VARIABLE { $$ = Stmt\StaticVar[parseVar($1), null]; }
442 | T_VARIABLE '=' static_scalar { $$ = Stmt\StaticVar[parseVar($1), $3]; }
443 ;
444
445 class_statement_list:
446 class_statement_list class_statement { push($1, $2); }
447 | /* empty */ { init(); }
448 ;
449
450 class_statement:
451 variable_modifiers property_declaration_list ';'
452 { $$ = Stmt\Property[$1, $2]; $this->checkProperty($$, #1); }
453 | T_CONST class_const_list ';' { $$ = Stmt\ClassConst[$2, 0]; }
454 | method_modifiers T_FUNCTION optional_ref identifier '(' parameter_list ')' optional_return_type method_body
455 { $$ = Stmt\ClassMethod[$4, ['type' => $1, 'byRef' => $3, 'params' => $6, 'returnType' => $8, 'stmts' => $9]];
456 $this->checkClassMethod($$, #1); }
457 | T_USE class_name_list trait_adaptations { $$ = Stmt\TraitUse[$2, $3]; }
458 ;
459
460 trait_adaptations:
461 ';' { $$ = array(); }
462 | '{' trait_adaptation_list '}' { $$ = $2; }
463 ;
464
465 trait_adaptation_list:
466 /* empty */ { init(); }
467 | trait_adaptation_list trait_adaptation { push($1, $2); }
468 ;
469
470 trait_adaptation:
471 trait_method_reference_fully_qualified T_INSTEADOF class_name_list ';'
472 { $$ = Stmt\TraitUseAdaptation\Precedence[$1[0], $1[1], $3]; }
473 | trait_method_reference T_AS member_modifier identifier ';'
474 { $$ = Stmt\TraitUseAdaptation\Alias[$1[0], $1[1], $3, $4]; }
475 | trait_method_reference T_AS member_modifier ';'
476 { $$ = Stmt\TraitUseAdaptation\Alias[$1[0], $1[1], $3, null]; }
477 | trait_method_reference T_AS T_STRING ';'
478 { $$ = Stmt\TraitUseAdaptation\Alias[$1[0], $1[1], null, $3]; }
479 | trait_method_reference T_AS reserved_non_modifiers ';'
480 { $$ = Stmt\TraitUseAdaptation\Alias[$1[0], $1[1], null, $3]; }
481 ;
482
483 trait_method_reference_fully_qualified:
484 name T_PAAMAYIM_NEKUDOTAYIM identifier { $$ = array($1, $3); }
485 ;
486 trait_method_reference:
487 trait_method_reference_fully_qualified { $$ = $1; }
488 | identifier { $$ = array(null, $1); }
489 ;
490
491 method_body:
492 ';' /* abstract method */ { $$ = null; }
493 | '{' inner_statement_list '}' { $$ = $2; }
494 ;
495
496 variable_modifiers:
497 non_empty_member_modifiers { $$ = $1; }
498 | T_VAR { $$ = 0; }
499 ;
500
501 method_modifiers:
502 /* empty */ { $$ = 0; }
503 | non_empty_member_modifiers { $$ = $1; }
504 ;
505
506 non_empty_member_modifiers:
507 member_modifier { $$ = $1; }
508 | non_empty_member_modifiers member_modifier { $this->checkModifier($1, $2, #2); $$ = $1 | $2; }
509 ;
510
511 member_modifier:
512 T_PUBLIC { $$ = Stmt\Class_::MODIFIER_PUBLIC; }
513 | T_PROTECTED { $$ = Stmt\Class_::MODIFIER_PROTECTED; }
514 | T_PRIVATE { $$ = Stmt\Class_::MODIFIER_PRIVATE; }
515 | T_STATIC { $$ = Stmt\Class_::MODIFIER_STATIC; }
516 | T_ABSTRACT { $$ = Stmt\Class_::MODIFIER_ABSTRACT; }
517 | T_FINAL { $$ = Stmt\Class_::MODIFIER_FINAL; }
518 ;
519
520 property_declaration_list:
521 property_declaration { init($1); }
522 | property_declaration_list ',' property_declaration { push($1, $3); }
523 ;
524
525 property_declaration:
526 T_VARIABLE { $$ = Stmt\PropertyProperty[parseVar($1), null]; }
527 | T_VARIABLE '=' static_scalar { $$ = Stmt\PropertyProperty[parseVar($1), $3]; }
528 ;
529
530 expr_list:
531 expr_list ',' expr { push($1, $3); }
532 | expr { init($1); }
533 ;
534
535 for_expr:
536 /* empty */ { $$ = array(); }
537 | expr_list { $$ = $1; }
538 ;
539
540 expr:
541 variable { $$ = $1; }
542 | list_expr '=' expr { $$ = Expr\Assign[$1, $3]; }
543 | variable '=' expr { $$ = Expr\Assign[$1, $3]; }
544 | variable '=' '&' variable { $$ = Expr\AssignRef[$1, $4]; }
545 | variable '=' '&' new_expr { $$ = Expr\AssignRef[$1, $4]; }
546 | new_expr { $$ = $1; }
547 | T_CLONE expr { $$ = Expr\Clone_[$2]; }
548 | variable T_PLUS_EQUAL expr { $$ = Expr\AssignOp\Plus [$1, $3]; }
549 | variable T_MINUS_EQUAL expr { $$ = Expr\AssignOp\Minus [$1, $3]; }
550 | variable T_MUL_EQUAL expr { $$ = Expr\AssignOp\Mul [$1, $3]; }
551 | variable T_DIV_EQUAL expr { $$ = Expr\AssignOp\Div [$1, $3]; }
552 | variable T_CONCAT_EQUAL expr { $$ = Expr\AssignOp\Concat [$1, $3]; }
553 | variable T_MOD_EQUAL expr { $$ = Expr\AssignOp\Mod [$1, $3]; }
554 | variable T_AND_EQUAL expr { $$ = Expr\AssignOp\BitwiseAnd[$1, $3]; }
555 | variable T_OR_EQUAL expr { $$ = Expr\AssignOp\BitwiseOr [$1, $3]; }
556 | variable T_XOR_EQUAL expr { $$ = Expr\AssignOp\BitwiseXor[$1, $3]; }
557 | variable T_SL_EQUAL expr { $$ = Expr\AssignOp\ShiftLeft [$1, $3]; }
558 | variable T_SR_EQUAL expr { $$ = Expr\AssignOp\ShiftRight[$1, $3]; }
559 | variable T_POW_EQUAL expr { $$ = Expr\AssignOp\Pow [$1, $3]; }
560 | variable T_INC { $$ = Expr\PostInc[$1]; }
561 | T_INC variable { $$ = Expr\PreInc [$2]; }
562 | variable T_DEC { $$ = Expr\PostDec[$1]; }
563 | T_DEC variable { $$ = Expr\PreDec [$2]; }
564 | expr T_BOOLEAN_OR expr { $$ = Expr\BinaryOp\BooleanOr [$1, $3]; }
565 | expr T_BOOLEAN_AND expr { $$ = Expr\BinaryOp\BooleanAnd[$1, $3]; }
566 | expr T_LOGICAL_OR expr { $$ = Expr\BinaryOp\LogicalOr [$1, $3]; }
567 | expr T_LOGICAL_AND expr { $$ = Expr\BinaryOp\LogicalAnd[$1, $3]; }
568 | expr T_LOGICAL_XOR expr { $$ = Expr\BinaryOp\LogicalXor[$1, $3]; }
569 | expr '|' expr { $$ = Expr\BinaryOp\BitwiseOr [$1, $3]; }
570 | expr '&' expr { $$ = Expr\BinaryOp\BitwiseAnd[$1, $3]; }
571 | expr '^' expr { $$ = Expr\BinaryOp\BitwiseXor[$1, $3]; }
572 | expr '.' expr { $$ = Expr\BinaryOp\Concat [$1, $3]; }
573 | expr '+' expr { $$ = Expr\BinaryOp\Plus [$1, $3]; }
574 | expr '-' expr { $$ = Expr\BinaryOp\Minus [$1, $3]; }
575 | expr '*' expr { $$ = Expr\BinaryOp\Mul [$1, $3]; }
576 | expr '/' expr { $$ = Expr\BinaryOp\Div [$1, $3]; }
577 | expr '%' expr { $$ = Expr\BinaryOp\Mod [$1, $3]; }
578 | expr T_SL expr { $$ = Expr\BinaryOp\ShiftLeft [$1, $3]; }
579 | expr T_SR expr { $$ = Expr\BinaryOp\ShiftRight[$1, $3]; }
580 | expr T_POW expr { $$ = Expr\BinaryOp\Pow [$1, $3]; }
581 | '+' expr %prec T_INC { $$ = Expr\UnaryPlus [$2]; }
582 | '-' expr %prec T_INC { $$ = Expr\UnaryMinus[$2]; }
583 | '!' expr { $$ = Expr\BooleanNot[$2]; }
584 | '~' expr { $$ = Expr\BitwiseNot[$2]; }
585 | expr T_IS_IDENTICAL expr { $$ = Expr\BinaryOp\Identical [$1, $3]; }
586 | expr T_IS_NOT_IDENTICAL expr { $$ = Expr\BinaryOp\NotIdentical [$1, $3]; }
587 | expr T_IS_EQUAL expr { $$ = Expr\BinaryOp\Equal [$1, $3]; }
588 | expr T_IS_NOT_EQUAL expr { $$ = Expr\BinaryOp\NotEqual [$1, $3]; }
589 | expr T_SPACESHIP expr { $$ = Expr\BinaryOp\Spaceship [$1, $3]; }
590 | expr '<' expr { $$ = Expr\BinaryOp\Smaller [$1, $3]; }
591 | expr T_IS_SMALLER_OR_EQUAL expr { $$ = Expr\BinaryOp\SmallerOrEqual[$1, $3]; }
592 | expr '>' expr { $$ = Expr\BinaryOp\Greater [$1, $3]; }
593 | expr T_IS_GREATER_OR_EQUAL expr { $$ = Expr\BinaryOp\GreaterOrEqual[$1, $3]; }
594 | expr T_INSTANCEOF class_name_reference { $$ = Expr\Instanceof_[$1, $3]; }
595 | parentheses_expr { $$ = $1; }
596 /* we need a separate '(' new_expr ')' rule to avoid problems caused by a s/r conflict */
597 | '(' new_expr ')' { $$ = $2; }
598 | expr '?' expr ':' expr { $$ = Expr\Ternary[$1, $3, $5]; }
599 | expr '?' ':' expr { $$ = Expr\Ternary[$1, null, $4]; }
600 | expr T_COALESCE expr { $$ = Expr\BinaryOp\Coalesce[$1, $3]; }
601 | T_ISSET '(' variables_list ')' { $$ = Expr\Isset_[$3]; }
602 | T_EMPTY '(' expr ')' { $$ = Expr\Empty_[$3]; }
603 | T_INCLUDE expr { $$ = Expr\Include_[$2, Expr\Include_::TYPE_INCLUDE]; }
604 | T_INCLUDE_ONCE expr { $$ = Expr\Include_[$2, Expr\Include_::TYPE_INCLUDE_ONCE]; }
605 | T_EVAL parentheses_expr { $$ = Expr\Eval_[$2]; }
606 | T_REQUIRE expr { $$ = Expr\Include_[$2, Expr\Include_::TYPE_REQUIRE]; }
607 | T_REQUIRE_ONCE expr { $$ = Expr\Include_[$2, Expr\Include_::TYPE_REQUIRE_ONCE]; }
608 | T_INT_CAST expr { $$ = Expr\Cast\Int_ [$2]; }
609 | T_DOUBLE_CAST expr { $$ = Expr\Cast\Double [$2]; }
610 | T_STRING_CAST expr { $$ = Expr\Cast\String_ [$2]; }
611 | T_ARRAY_CAST expr { $$ = Expr\Cast\Array_ [$2]; }
612 | T_OBJECT_CAST expr { $$ = Expr\Cast\Object_ [$2]; }
613 | T_BOOL_CAST expr { $$ = Expr\Cast\Bool_ [$2]; }
614 | T_UNSET_CAST expr { $$ = Expr\Cast\Unset_ [$2]; }
615 | T_EXIT exit_expr
616 { $attrs = attributes();
617 $attrs['kind'] = strtolower($1) === 'exit' ? Expr\Exit_::KIND_EXIT : Expr\Exit_::KIND_DIE;
618 $$ = new Expr\Exit_($2, $attrs); }
619 | '@' expr { $$ = Expr\ErrorSuppress[$2]; }
620 | scalar { $$ = $1; }
621 | array_expr { $$ = $1; }
622 | scalar_dereference { $$ = $1; }
623 | '`' backticks_expr '`' { $$ = Expr\ShellExec[$2]; }
624 | T_PRINT expr { $$ = Expr\Print_[$2]; }
625 | T_YIELD { $$ = Expr\Yield_[null, null]; }
626 | T_YIELD_FROM expr { $$ = Expr\YieldFrom[$2]; }
627 | T_FUNCTION optional_ref '(' parameter_list ')' lexical_vars optional_return_type
628 '{' inner_statement_list '}'
629 { $$ = Expr\Closure[['static' => false, 'byRef' => $2, 'params' => $4, 'uses' => $6, 'returnType' => $7, 'stmts' => $9]]; }
630 | T_STATIC T_FUNCTION optional_ref '(' parameter_list ')' lexical_vars optional_return_type
631 '{' inner_statement_list '}'
632 { $$ = Expr\Closure[['static' => true, 'byRef' => $3, 'params' => $5, 'uses' => $7, 'returnType' => $8, 'stmts' => $10]]; }
633 ;
634
635 parentheses_expr:
636 '(' expr ')' { $$ = $2; }
637 | '(' yield_expr ')' { $$ = $2; }
638 ;
639
640 yield_expr:
641 T_YIELD expr { $$ = Expr\Yield_[$2, null]; }
642 | T_YIELD expr T_DOUBLE_ARROW expr { $$ = Expr\Yield_[$4, $2]; }
643 ;
644
645 array_expr:
646 T_ARRAY '(' array_pair_list ')'
647 { $attrs = attributes(); $attrs['kind'] = Expr\Array_::KIND_LONG;
648 $$ = new Expr\Array_($3, $attrs); }
649 | '[' array_pair_list ']'
650 { $attrs = attributes(); $attrs['kind'] = Expr\Array_::KIND_SHORT;
651 $$ = new Expr\Array_($2, $attrs); }
652 ;
653
654 scalar_dereference:
655 array_expr '[' dim_offset ']' { $$ = Expr\ArrayDimFetch[$1, $3]; }
656 | T_CONSTANT_ENCAPSED_STRING '[' dim_offset ']'
657 { $attrs = attributes(); $attrs['kind'] = strKind($1);
658 $$ = Expr\ArrayDimFetch[new Scalar\String_(Scalar\String_::parse($1), $attrs), $3]; }
659 | constant '[' dim_offset ']' { $$ = Expr\ArrayDimFetch[$1, $3]; }
660 | scalar_dereference '[' dim_offset ']' { $$ = Expr\ArrayDimFetch[$1, $3]; }
661 /* alternative array syntax missing intentionally */
662 ;
663
664 anonymous_class:
665 T_CLASS ctor_arguments extends_from implements_list '{' class_statement_list '}'
666 { $$ = array(Stmt\Class_[null, ['type' => 0, 'extends' => $3, 'implements' => $4, 'stmts' => $6]], $2);
667 $this->checkClass($$[0], -1); }
668
669 new_expr:
670 T_NEW class_name_reference ctor_arguments { $$ = Expr\New_[$2, $3]; }
671 | T_NEW anonymous_class
672 { list($class, $ctorArgs) = $2; $$ = Expr\New_[$class, $ctorArgs]; }
673 ;
674
675 lexical_vars:
676 /* empty */ { $$ = array(); }
677 | T_USE '(' lexical_var_list ')' { $$ = $3; }
678 ;
679
680 lexical_var_list:
681 lexical_var { init($1); }
682 | lexical_var_list ',' lexical_var { push($1, $3); }
683 ;
684
685 lexical_var:
686 optional_ref T_VARIABLE { $$ = Expr\ClosureUse[parseVar($2), $1]; }
687 ;
688
689 function_call:
690 name argument_list { $$ = Expr\FuncCall[$1, $2]; }
691 | class_name_or_var T_PAAMAYIM_NEKUDOTAYIM identifier argument_list
692 { $$ = Expr\StaticCall[$1, $3, $4]; }
693 | class_name_or_var T_PAAMAYIM_NEKUDOTAYIM '{' expr '}' argument_list
694 { $$ = Expr\StaticCall[$1, $4, $6]; }
695 | static_property argument_list {
696 if ($1 instanceof Node\Expr\StaticPropertyFetch) {
697 $$ = Expr\StaticCall[$1->class, Expr\Variable[$1->name], $2];
698 } elseif ($1 instanceof Node\Expr\ArrayDimFetch) {
699 $tmp = $1;
700 while ($tmp->var instanceof Node\Expr\ArrayDimFetch) {
701 $tmp = $tmp->var;
702 }
703
704 $$ = Expr\StaticCall[$tmp->var->class, $1, $2];
705 $tmp->var = Expr\Variable[$tmp->var->name];
706 } else {
707 throw new \Exception;
708 }
709 }
710 | variable_without_objects argument_list
711 { $$ = Expr\FuncCall[$1, $2]; }
712 | function_call '[' dim_offset ']' { $$ = Expr\ArrayDimFetch[$1, $3]; }
713 /* alternative array syntax missing intentionally */
714 ;
715
716 class_name:
717 T_STATIC { $$ = Name[$1]; }
718 | name { $$ = $1; }
719 ;
720
721 name:
722 namespace_name_parts { $$ = Name[$1]; }
723 | T_NS_SEPARATOR namespace_name_parts { $$ = Name\FullyQualified[$2]; }
724 | T_NAMESPACE T_NS_SEPARATOR namespace_name_parts { $$ = Name\Relative[$3]; }
725 ;
726
727 class_name_reference:
728 class_name { $$ = $1; }
729 | dynamic_class_name_reference { $$ = $1; }
730 ;
731
732 dynamic_class_name_reference:
733 object_access_for_dcnr { $$ = $1; }
734 | base_variable { $$ = $1; }
735 ;
736
737 class_name_or_var:
738 class_name { $$ = $1; }
739 | reference_variable { $$ = $1; }
740 ;
741
742 object_access_for_dcnr:
743 base_variable T_OBJECT_OPERATOR object_property
744 { $$ = Expr\PropertyFetch[$1, $3]; }
745 | object_access_for_dcnr T_OBJECT_OPERATOR object_property
746 { $$ = Expr\PropertyFetch[$1, $3]; }
747 | object_access_for_dcnr '[' dim_offset ']' { $$ = Expr\ArrayDimFetch[$1, $3]; }
748 | object_access_for_dcnr '{' expr '}' { $$ = Expr\ArrayDimFetch[$1, $3]; }
749 ;
750
751 exit_expr:
752 /* empty */ { $$ = null; }
753 | '(' ')' { $$ = null; }
754 | parentheses_expr { $$ = $1; }
755 ;
756
757 backticks_expr:
758 /* empty */ { $$ = array(); }
759 | T_ENCAPSED_AND_WHITESPACE
760 { $$ = array(Scalar\EncapsedStringPart[Scalar\String_::parseEscapeSequences($1, '`', false)]); }
761 | encaps_list { parseEncapsed($1, '`', false); $$ = $1; }
762 ;
763
764 ctor_arguments:
765 /* empty */ { $$ = array(); }
766 | argument_list { $$ = $1; }
767 ;
768
769 common_scalar:
770 T_LNUMBER { $$ = $this->parseLNumber($1, attributes(), true); }
771 | T_DNUMBER { $$ = Scalar\DNumber[Scalar\DNumber::parse($1)]; }
772 | T_CONSTANT_ENCAPSED_STRING
773 { $attrs = attributes(); $attrs['kind'] = strKind($1);
774 $$ = new Scalar\String_(Scalar\String_::parse($1, false), $attrs); }
775 | T_LINE { $$ = Scalar\MagicConst\Line[]; }
776 | T_FILE { $$ = Scalar\MagicConst\File[]; }
777 | T_DIR { $$ = Scalar\MagicConst\Dir[]; }
778 | T_CLASS_C { $$ = Scalar\MagicConst\Class_[]; }
779 | T_TRAIT_C { $$ = Scalar\MagicConst\Trait_[]; }
780 | T_METHOD_C { $$ = Scalar\MagicConst\Method[]; }
781 | T_FUNC_C { $$ = Scalar\MagicConst\Function_[]; }
782 | T_NS_C { $$ = Scalar\MagicConst\Namespace_[]; }
783 | T_START_HEREDOC T_ENCAPSED_AND_WHITESPACE T_END_HEREDOC
784 { $attrs = attributes(); setDocStringAttrs($attrs, $1);
785 $$ = new Scalar\String_(Scalar\String_::parseDocString($1, $2, false), $attrs); }
786 | T_START_HEREDOC T_END_HEREDOC
787 { $attrs = attributes(); setDocStringAttrs($attrs, $1);
788 $$ = new Scalar\String_('', $attrs); }
789 ;
790
791 static_scalar:
792 common_scalar { $$ = $1; }
793 | class_name T_PAAMAYIM_NEKUDOTAYIM identifier { $$ = Expr\ClassConstFetch[$1, $3]; }
794 | name { $$ = Expr\ConstFetch[$1]; }
795 | T_ARRAY '(' static_array_pair_list ')' { $$ = Expr\Array_[$3]; }
796 | '[' static_array_pair_list ']' { $$ = Expr\Array_[$2]; }
797 | static_operation { $$ = $1; }
798 ;
799
800 static_operation:
801 static_scalar T_BOOLEAN_OR static_scalar { $$ = Expr\BinaryOp\BooleanOr [$1, $3]; }
802 | static_scalar T_BOOLEAN_AND static_scalar { $$ = Expr\BinaryOp\BooleanAnd[$1, $3]; }
803 | static_scalar T_LOGICAL_OR static_scalar { $$ = Expr\BinaryOp\LogicalOr [$1, $3]; }
804 | static_scalar T_LOGICAL_AND static_scalar { $$ = Expr\BinaryOp\LogicalAnd[$1, $3]; }
805 | static_scalar T_LOGICAL_XOR static_scalar { $$ = Expr\BinaryOp\LogicalXor[$1, $3]; }
806 | static_scalar '|' static_scalar { $$ = Expr\BinaryOp\BitwiseOr [$1, $3]; }
807 | static_scalar '&' static_scalar { $$ = Expr\BinaryOp\BitwiseAnd[$1, $3]; }
808 | static_scalar '^' static_scalar { $$ = Expr\BinaryOp\BitwiseXor[$1, $3]; }
809 | static_scalar '.' static_scalar { $$ = Expr\BinaryOp\Concat [$1, $3]; }
810 | static_scalar '+' static_scalar { $$ = Expr\BinaryOp\Plus [$1, $3]; }
811 | static_scalar '-' static_scalar { $$ = Expr\BinaryOp\Minus [$1, $3]; }
812 | static_scalar '*' static_scalar { $$ = Expr\BinaryOp\Mul [$1, $3]; }
813 | static_scalar '/' static_scalar { $$ = Expr\BinaryOp\Div [$1, $3]; }
814 | static_scalar '%' static_scalar { $$ = Expr\BinaryOp\Mod [$1, $3]; }
815 | static_scalar T_SL static_scalar { $$ = Expr\BinaryOp\ShiftLeft [$1, $3]; }
816 | static_scalar T_SR static_scalar { $$ = Expr\BinaryOp\ShiftRight[$1, $3]; }
817 | static_scalar T_POW static_scalar { $$ = Expr\BinaryOp\Pow [$1, $3]; }
818 | '+' static_scalar %prec T_INC { $$ = Expr\UnaryPlus [$2]; }
819 | '-' static_scalar %prec T_INC { $$ = Expr\UnaryMinus[$2]; }
820 | '!' static_scalar { $$ = Expr\BooleanNot[$2]; }
821 | '~' static_scalar { $$ = Expr\BitwiseNot[$2]; }
822 | static_scalar T_IS_IDENTICAL static_scalar { $$ = Expr\BinaryOp\Identical [$1, $3]; }
823 | static_scalar T_IS_NOT_IDENTICAL static_scalar { $$ = Expr\BinaryOp\NotIdentical [$1, $3]; }
824 | static_scalar T_IS_EQUAL static_scalar { $$ = Expr\BinaryOp\Equal [$1, $3]; }
825 | static_scalar T_IS_NOT_EQUAL static_scalar { $$ = Expr\BinaryOp\NotEqual [$1, $3]; }
826 | static_scalar '<' static_scalar { $$ = Expr\BinaryOp\Smaller [$1, $3]; }
827 | static_scalar T_IS_SMALLER_OR_EQUAL static_scalar { $$ = Expr\BinaryOp\SmallerOrEqual[$1, $3]; }
828 | static_scalar '>' static_scalar { $$ = Expr\BinaryOp\Greater [$1, $3]; }
829 | static_scalar T_IS_GREATER_OR_EQUAL static_scalar { $$ = Expr\BinaryOp\GreaterOrEqual[$1, $3]; }
830 | static_scalar '?' static_scalar ':' static_scalar { $$ = Expr\Ternary[$1, $3, $5]; }
831 | static_scalar '?' ':' static_scalar { $$ = Expr\Ternary[$1, null, $4]; }
832 | static_scalar '[' static_scalar ']' { $$ = Expr\ArrayDimFetch[$1, $3]; }
833 | '(' static_scalar ')' { $$ = $2; }
834 ;
835
836 constant:
837 name { $$ = Expr\ConstFetch[$1]; }
838 | class_name_or_var T_PAAMAYIM_NEKUDOTAYIM identifier
839 { $$ = Expr\ClassConstFetch[$1, $3]; }
840 ;
841
842 scalar:
843 common_scalar { $$ = $1; }
844 | constant { $$ = $1; }
845 | '"' encaps_list '"'
846 { $attrs = attributes(); $attrs['kind'] = Scalar\String_::KIND_DOUBLE_QUOTED;
847 parseEncapsed($2, '"', true); $$ = new Scalar\Encapsed($2, $attrs); }
848 | T_START_HEREDOC encaps_list T_END_HEREDOC
849 { $attrs = attributes(); setDocStringAttrs($attrs, $1);
850 parseEncapsedDoc($2, true); $$ = new Scalar\Encapsed($2, $attrs); }
851 ;
852
853 static_array_pair_list:
854 /* empty */ { $$ = array(); }
855 | non_empty_static_array_pair_list optional_comma { $$ = $1; }
856 ;
857
858 optional_comma:
859 /* empty */
860 | ','
861 ;
862
863 non_empty_static_array_pair_list:
864 non_empty_static_array_pair_list ',' static_array_pair { push($1, $3); }
865 | static_array_pair { init($1); }
866 ;
867
868 static_array_pair:
869 static_scalar T_DOUBLE_ARROW static_scalar { $$ = Expr\ArrayItem[$3, $1, false]; }
870 | static_scalar { $$ = Expr\ArrayItem[$1, null, false]; }
871 ;
872
873 variable:
874 object_access { $$ = $1; }
875 | base_variable { $$ = $1; }
876 | function_call { $$ = $1; }
877 | new_expr_array_deref { $$ = $1; }
878 ;
879
880 new_expr_array_deref:
881 '(' new_expr ')' '[' dim_offset ']' { $$ = Expr\ArrayDimFetch[$2, $5]; }
882 | new_expr_array_deref '[' dim_offset ']' { $$ = Expr\ArrayDimFetch[$1, $3]; }
883 /* alternative array syntax missing intentionally */
884 ;
885
886 object_access:
887 variable_or_new_expr T_OBJECT_OPERATOR object_property
888 { $$ = Expr\PropertyFetch[$1, $3]; }
889 | variable_or_new_expr T_OBJECT_OPERATOR object_property argument_list
890 { $$ = Expr\MethodCall[$1, $3, $4]; }
891 | object_access argument_list { $$ = Expr\FuncCall[$1, $2]; }
892 | object_access '[' dim_offset ']' { $$ = Expr\ArrayDimFetch[$1, $3]; }
893 | object_access '{' expr '}' { $$ = Expr\ArrayDimFetch[$1, $3]; }
894 ;
895
896 variable_or_new_expr:
897 variable { $$ = $1; }
898 | '(' new_expr ')' { $$ = $2; }
899 ;
900
901 variable_without_objects:
902 reference_variable { $$ = $1; }
903 | '$' variable_without_objects { $$ = Expr\Variable[$2]; }
904 ;
905
906 base_variable:
907 variable_without_objects { $$ = $1; }
908 | static_property { $$ = $1; }
909 ;
910
911 static_property:
912 class_name_or_var T_PAAMAYIM_NEKUDOTAYIM '$' reference_variable
913 { $$ = Expr\StaticPropertyFetch[$1, $4]; }
914 | static_property_with_arrays { $$ = $1; }
915 ;
916
917 static_property_with_arrays:
918 class_name_or_var T_PAAMAYIM_NEKUDOTAYIM T_VARIABLE
919 { $$ = Expr\StaticPropertyFetch[$1, parseVar($3)]; }
920 | class_name_or_var T_PAAMAYIM_NEKUDOTAYIM '$' '{' expr '}'
921 { $$ = Expr\StaticPropertyFetch[$1, $5]; }
922 | static_property_with_arrays '[' dim_offset ']' { $$ = Expr\ArrayDimFetch[$1, $3]; }
923 | static_property_with_arrays '{' expr '}' { $$ = Expr\ArrayDimFetch[$1, $3]; }
924 ;
925
926 reference_variable:
927 reference_variable '[' dim_offset ']' { $$ = Expr\ArrayDimFetch[$1, $3]; }
928 | reference_variable '{' expr '}' { $$ = Expr\ArrayDimFetch[$1, $3]; }
929 | T_VARIABLE { $$ = Expr\Variable[parseVar($1)]; }
930 | '$' '{' expr '}' { $$ = Expr\Variable[$3]; }
931 ;
932
933 dim_offset:
934 /* empty */ { $$ = null; }
935 | expr { $$ = $1; }
936 ;
937
938 object_property:
939 T_STRING { $$ = $1; }
940 | '{' expr '}' { $$ = $2; }
941 | variable_without_objects { $$ = $1; }
942 | error { $$ = Expr\Error[]; $this->errorState = 2; }
943 ;
944
945 list_expr:
946 T_LIST '(' list_expr_elements ')' { $$ = Expr\List_[$3]; }
947 ;
948
949 list_expr_elements:
950 list_expr_elements ',' list_expr_element { push($1, $3); }
951 | list_expr_element { init($1); }
952 ;
953
954 list_expr_element:
955 variable { $$ = Expr\ArrayItem[$1, null, false]; }
956 | list_expr { $$ = Expr\ArrayItem[$1, null, false]; }
957 | /* empty */ { $$ = null; }
958 ;
959
960 array_pair_list:
961 /* empty */ { $$ = array(); }
962 | non_empty_array_pair_list optional_comma { $$ = $1; }
963 ;
964
965 non_empty_array_pair_list:
966 non_empty_array_pair_list ',' array_pair { push($1, $3); }
967 | array_pair { init($1); }
968 ;
969
970 array_pair:
971 expr T_DOUBLE_ARROW expr { $$ = Expr\ArrayItem[$3, $1, false]; }
972 | expr { $$ = Expr\ArrayItem[$1, null, false]; }
973 | expr T_DOUBLE_ARROW '&' variable { $$ = Expr\ArrayItem[$4, $1, true]; }
974 | '&' variable { $$ = Expr\ArrayItem[$2, null, true]; }
975 ;
976
977 encaps_list:
978 encaps_list encaps_var { push($1, $2); }
979 | encaps_list encaps_string_part { push($1, $2); }
980 | encaps_var { init($1); }
981 | encaps_string_part encaps_var { init($1, $2); }
982 ;
983
984 encaps_string_part:
985 T_ENCAPSED_AND_WHITESPACE { $$ = Scalar\EncapsedStringPart[$1]; }
986 ;
987
988 encaps_base_var:
989 T_VARIABLE { $$ = Expr\Variable[parseVar($1)]; }
990 ;
991
992 encaps_var:
993 encaps_base_var { $$ = $1; }
994 | encaps_base_var '[' encaps_var_offset ']' { $$ = Expr\ArrayDimFetch[$1, $3]; }
995 | encaps_base_var T_OBJECT_OPERATOR T_STRING { $$ = Expr\PropertyFetch[$1, $3]; }
996 | T_DOLLAR_OPEN_CURLY_BRACES expr '}' { $$ = Expr\Variable[$2]; }
997 | T_DOLLAR_OPEN_CURLY_BRACES T_STRING_VARNAME '}' { $$ = Expr\Variable[$2]; }
998 | T_DOLLAR_OPEN_CURLY_BRACES T_STRING_VARNAME '[' expr ']' '}'
999 { $$ = Expr\ArrayDimFetch[Expr\Variable[$2], $4]; }
1000 | T_CURLY_OPEN variable '}' { $$ = $2; }
1001 ;
1002
1003 encaps_var_offset:
1004 T_STRING { $$ = Scalar\String_[$1]; }
1005 | T_NUM_STRING { $$ = $this->parseNumString($1, attributes()); }
1006 | T_VARIABLE { $$ = Expr\Variable[parseVar($1)]; }
1007 ;
1008
1009 %%