yaffs.net Git - yaffs-website/blob - vendor/nikic/php-parser/grammar/php5.y

   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_ex    { $$ = Stmt\Case_[$2, $4]; }
 327     | T_DEFAULT case_separator inner_statement_list_ex      { $$ = 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 %%