perly.act

   1 /* -*- buffer-read-only: t -*-
   2    !!!!!!!   DO NOT EDIT THIS FILE   !!!!!!!
   3    This file is built by regen_perly.pl from perly.y.
   4    Any changes made here will be lost!
   5  */
   6
   7 case 2:
   8 #line 114 "perly.y"
   9     {
  10                           parser->expect = XSTATE;
  11                         ;}
  12     break;
  13
  14   case 3:
  15 #line 118 "perly.y"
  16     {
  17                           newPROG(block_end((ps[(3) - (4)].val.ival),(ps[(4) - (4)].val.opval)));
  18                           (yyval.ival) = 0;
  19                         ;}
  20     break;
  21
  22   case 4:
  23 #line 123 "perly.y"
  24     {
  25                           parser->expect = XTERM;
  26                         ;}
  27     break;
  28
  29   case 5:
  30 #line 127 "perly.y"
  31     {
  32                           PL_eval_root = (ps[(3) - (3)].val.opval);
  33                           (yyval.ival) = 0;
  34                         ;}
  35     break;
  36
  37   case 6:
  38 #line 132 "perly.y"
  39     {
  40                           parser->expect = XBLOCK;
  41                         ;}
  42     break;
  43
  44   case 7:
  45 #line 136 "perly.y"
  46     {
  47                           PL_pad_reset_pending = TRUE;
  48                           PL_eval_root = (ps[(3) - (3)].val.opval);
  49                           (yyval.ival) = 0;
  50                           yyunlex();
  51                           parser->yychar = YYEOF;
  52                         ;}
  53     break;
  54
  55   case 8:
  56 #line 144 "perly.y"
  57     {
  58                           parser->expect = XSTATE;
  59                         ;}
  60     break;
  61
  62   case 9:
  63 #line 148 "perly.y"
  64     {
  65                           PL_pad_reset_pending = TRUE;
  66                           PL_eval_root = (ps[(3) - (3)].val.opval);
  67                           (yyval.ival) = 0;
  68                           yyunlex();
  69                           parser->yychar = YYEOF;
  70                         ;}
  71     break;
  72
  73   case 10:
  74 #line 156 "perly.y"
  75     {
  76                           parser->expect = XSTATE;
  77                         ;}
  78     break;
  79
  80   case 11:
  81 #line 160 "perly.y"
  82     {
  83                           PL_pad_reset_pending = TRUE;
  84                           PL_eval_root = (ps[(3) - (3)].val.opval);
  85                           (yyval.ival) = 0;
  86                           yyunlex();
  87                           parser->yychar = YYEOF;
  88                         ;}
  89     break;
  90
  91   case 12:
  92 #line 168 "perly.y"
  93     {
  94                           parser->expect = XSTATE;
  95                         ;}
  96     break;
  97
  98   case 13:
  99 #line 172 "perly.y"
 100     {
 101                           PL_eval_root = (ps[(3) - (3)].val.opval);
 102                           (yyval.ival) = 0;
 103                         ;}
 104     break;
 105
 106   case 14:
 107 #line 180 "perly.y"
 108     { if (parser->copline > (line_t)(ps[(1) - (4)].val.ival))
 109                               parser->copline = (line_t)(ps[(1) - (4)].val.ival);
 110                           (yyval.opval) = block_end((ps[(2) - (4)].val.ival), (ps[(3) - (4)].val.opval));
 111                         ;}
 112     break;
 113
 114   case 15:
 115 #line 188 "perly.y"
 116     { if (parser->copline > (line_t)(ps[(1) - (7)].val.ival))
 117                               parser->copline = (line_t)(ps[(1) - (7)].val.ival);
 118                           (yyval.opval) = block_end((ps[(2) - (7)].val.ival), (ps[(5) - (7)].val.opval));
 119                         ;}
 120     break;
 121
 122   case 16:
 123 #line 195 "perly.y"
 124     { (yyval.ival) = block_start(TRUE); ;}
 125     break;
 126
 127   case 17:
 128 #line 199 "perly.y"
 129     { if (parser->copline > (line_t)(ps[(1) - (4)].val.ival))
 130                               parser->copline = (line_t)(ps[(1) - (4)].val.ival);
 131                           (yyval.opval) = block_end((ps[(2) - (4)].val.ival), (ps[(3) - (4)].val.opval));
 132                         ;}
 133     break;
 134
 135   case 18:
 136 #line 206 "perly.y"
 137     { (yyval.ival) = block_start(FALSE); ;}
 138     break;
 139
 140   case 19:
 141 #line 211 "perly.y"
 142     { (yyval.opval) = (OP*)NULL; ;}
 143     break;
 144
 145   case 20:
 146 #line 213 "perly.y"
 147     {   (yyval.opval) = op_append_list(OP_LINESEQ, (ps[(1) - (2)].val.opval), (ps[(2) - (2)].val.opval));
 148                             PL_pad_reset_pending = TRUE;
 149                             if ((ps[(1) - (2)].val.opval) && (ps[(2) - (2)].val.opval))
 150                                 PL_hints |= HINT_BLOCK_SCOPE;
 151                         ;}
 152     break;
 153
 154   case 21:
 155 #line 222 "perly.y"
 156     { (yyval.opval) = (OP*)NULL; ;}
 157     break;
 158
 159   case 22:
 160 #line 224 "perly.y"
 161     {   (yyval.opval) = op_append_list(OP_LINESEQ, (ps[(1) - (2)].val.opval), (ps[(2) - (2)].val.opval));
 162                             PL_pad_reset_pending = TRUE;
 163                             if ((ps[(1) - (2)].val.opval) && (ps[(2) - (2)].val.opval))
 164                                 PL_hints |= HINT_BLOCK_SCOPE;
 165                         ;}
 166     break;
 167
 168   case 23:
 169 #line 233 "perly.y"
 170     {
 171                           (yyval.opval) = (ps[(1) - (1)].val.opval) ? newSTATEOP(0, NULL, (ps[(1) - (1)].val.opval)) : NULL;
 172                         ;}
 173     break;
 174
 175   case 24:
 176 #line 237 "perly.y"
 177     { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
 178     break;
 179
 180   case 25:
 181 #line 241 "perly.y"
 182     {
 183                           (yyval.opval) = newSTATEOP(SVf_UTF8 * (ps[(1) - (2)].val.pval)[strlen((ps[(1) - (2)].val.pval))+1], (ps[(1) - (2)].val.pval), (ps[(2) - (2)].val.opval));
 184                         ;}
 185     break;
 186
 187   case 26:
 188 #line 245 "perly.y"
 189     {
 190                           (yyval.opval) = newSTATEOP(SVf_UTF8 * (ps[(1) - (2)].val.pval)[strlen((ps[(1) - (2)].val.pval))+1], (ps[(1) - (2)].val.pval), (ps[(2) - (2)].val.opval));
 191                         ;}
 192     break;
 193
 194   case 27:
 195 #line 252 "perly.y"
 196     { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
 197     break;
 198
 199   case 28:
 200 #line 254 "perly.y"
 201     {
 202                           CV *fmtcv = PL_compcv;
 203                           newFORM((ps[(2) - (4)].val.ival), (ps[(3) - (4)].val.opval), (ps[(4) - (4)].val.opval));
 204                           (yyval.opval) = (OP*)NULL;
 205                           if (CvOUTSIDE(fmtcv) && !CvEVAL(CvOUTSIDE(fmtcv))) {
 206                               SvREFCNT_inc_simple_void(fmtcv);
 207                               pad_add_anon(fmtcv, OP_NULL);
 208                           }
 209                         ;}
 210     break;
 211
 212   case 29:
 213 #line 264 "perly.y"
 214     {
 215                           if ((ps[(2) - (3)].val.opval)->op_type == OP_CONST) {
 216                             const char *const name =
 217                                 SvPV_nolen_const(((SVOP*)(ps[(2) - (3)].val.opval))->op_sv);
 218                             if (strEQ(name, "BEGIN") || strEQ(name, "END")
 219                               || strEQ(name, "INIT") || strEQ(name, "CHECK")
 220                               || strEQ(name, "UNITCHECK"))
 221                               CvSPECIAL_on(PL_compcv);
 222                           }
 223                           else
 224                           /* State subs inside anonymous subs need to be
 225                              clonable themselves. */
 226                           if (CvANON(CvOUTSIDE(PL_compcv))
 227                            || CvCLONE(CvOUTSIDE(PL_compcv))
 228                            || !PadnameIsSTATE(PadlistNAMESARRAY(CvPADLIST(
 229                                                 CvOUTSIDE(PL_compcv)
 230                                              ))[(ps[(2) - (3)].val.opval)->op_targ]))
 231                               CvCLONE_on(PL_compcv);
 232                           parser->in_my = 0;
 233                           parser->in_my_stash = NULL;
 234                         ;}
 235     break;
 236
 237   case 30:
 238 #line 286 "perly.y"
 239     {
 240                           SvREFCNT_inc_simple_void(PL_compcv);
 241                           (ps[(2) - (7)].val.opval)->op_type == OP_CONST
 242                               ? newATTRSUB((ps[(3) - (7)].val.ival), (ps[(2) - (7)].val.opval), (ps[(5) - (7)].val.opval), (ps[(6) - (7)].val.opval), (ps[(7) - (7)].val.opval))
 243                               : newMYSUB((ps[(3) - (7)].val.ival), (ps[(2) - (7)].val.opval), (ps[(5) - (7)].val.opval), (ps[(6) - (7)].val.opval), (ps[(7) - (7)].val.opval))
 244                           ;
 245                           (yyval.opval) = (OP*)NULL;
 246                           intro_my();
 247                         ;}
 248     break;
 249
 250   case 31:
 251 #line 296 "perly.y"
 252     {
 253                           package((ps[(3) - (4)].val.opval));
 254                           if ((ps[(2) - (4)].val.opval))
 255                               package_version((ps[(2) - (4)].val.opval));
 256                           (yyval.opval) = (OP*)NULL;
 257                         ;}
 258     break;
 259
 260   case 32:
 261 #line 303 "perly.y"
 262     { CvSPECIAL_on(PL_compcv); /* It's a BEGIN {} */ ;}
 263     break;
 264
 265   case 33:
 266 #line 305 "perly.y"
 267     {
 268                           SvREFCNT_inc_simple_void(PL_compcv);
 269                           utilize((ps[(1) - (7)].val.ival), (ps[(2) - (7)].val.ival), (ps[(4) - (7)].val.opval), (ps[(5) - (7)].val.opval), (ps[(6) - (7)].val.opval));
 270                           (yyval.opval) = (OP*)NULL;
 271                         ;}
 272     break;
 273
 274   case 34:
 275 #line 311 "perly.y"
 276     {
 277                           (yyval.opval) = block_end((ps[(3) - (7)].val.ival),
 278                               newCONDOP(0, (ps[(4) - (7)].val.opval), op_scope((ps[(6) - (7)].val.opval)), (ps[(7) - (7)].val.opval)));
 279                           parser->copline = (line_t)(ps[(1) - (7)].val.ival);
 280                         ;}
 281     break;
 282
 283   case 35:
 284 #line 317 "perly.y"
 285     {
 286                           (yyval.opval) = block_end((ps[(3) - (7)].val.ival),
 287                               newCONDOP(0, (ps[(4) - (7)].val.opval), op_scope((ps[(6) - (7)].val.opval)), (ps[(7) - (7)].val.opval)));
 288                           parser->copline = (line_t)(ps[(1) - (7)].val.ival);
 289                         ;}
 290     break;
 291
 292   case 36:
 293 #line 323 "perly.y"
 294     {
 295                           const PADOFFSET offset = pad_findmy_pvs("$_", 0);
 296                           (yyval.opval) = block_end((ps[(3) - (6)].val.ival),
 297                                   newGIVENOP((ps[(4) - (6)].val.opval), op_scope((ps[(6) - (6)].val.opval)),
 298                                     offset == NOT_IN_PAD
 299                                     || PAD_COMPNAME_FLAGS_isOUR(offset)
 300                                       ? 0
 301                                       : offset));
 302                           parser->copline = (line_t)(ps[(1) - (6)].val.ival);
 303                         ;}
 304     break;
 305
 306   case 37:
 307 #line 334 "perly.y"
 308     { (yyval.opval) = block_end((ps[(3) - (6)].val.ival), newWHENOP((ps[(4) - (6)].val.opval), op_scope((ps[(6) - (6)].val.opval)))); ;}
 309     break;
 310
 311   case 38:
 312 #line 336 "perly.y"
 313     { (yyval.opval) = newWHENOP(0, op_scope((ps[(2) - (2)].val.opval))); ;}
 314     break;
 315
 316   case 39:
 317 #line 338 "perly.y"
 318     {
 319                           (yyval.opval) = block_end((ps[(3) - (8)].val.ival),
 320                                   newWHILEOP(0, 1, (LOOP*)(OP*)NULL,
 321                                       (ps[(4) - (8)].val.opval), (ps[(7) - (8)].val.opval), (ps[(8) - (8)].val.opval), (ps[(6) - (8)].val.ival)));
 322                           parser->copline = (line_t)(ps[(1) - (8)].val.ival);
 323                         ;}
 324     break;
 325
 326   case 40:
 327 #line 345 "perly.y"
 328     {
 329                           (yyval.opval) = block_end((ps[(3) - (8)].val.ival),
 330                                   newWHILEOP(0, 1, (LOOP*)(OP*)NULL,
 331                                       (ps[(4) - (8)].val.opval), (ps[(7) - (8)].val.opval), (ps[(8) - (8)].val.opval), (ps[(6) - (8)].val.ival)));
 332                           parser->copline = (line_t)(ps[(1) - (8)].val.ival);
 333                         ;}
 334     break;
 335
 336   case 41:
 337 #line 352 "perly.y"
 338     { parser->expect = XTERM; ;}
 339     break;
 340
 341   case 42:
 342 #line 354 "perly.y"
 343     { parser->expect = XTERM; ;}
 344     break;
 345
 346   case 43:
 347 #line 357 "perly.y"
 348     {
 349                           OP *initop = (ps[(4) - (13)].val.opval);
 350                           OP *forop = newWHILEOP(0, 1, (LOOP*)(OP*)NULL,
 351                                       scalar((ps[(7) - (13)].val.opval)), (ps[(13) - (13)].val.opval), (ps[(11) - (13)].val.opval), (ps[(10) - (13)].val.ival));
 352                           if (initop) {
 353                               forop = op_prepend_elem(OP_LINESEQ, initop,
 354                                   op_append_elem(OP_LINESEQ,
 355                                       newOP(OP_UNSTACK, OPf_SPECIAL),
 356                                       forop));
 357                           }
 358                           (yyval.opval) = block_end((ps[(3) - (13)].val.ival), forop);
 359                           parser->copline = (line_t)(ps[(1) - (13)].val.ival);
 360                         ;}
 361     break;
 362
 363   case 44:
 364 #line 371 "perly.y"
 365     {
 366                           (yyval.opval) = block_end((ps[(3) - (9)].val.ival), newFOROP(0, (ps[(4) - (9)].val.opval), (ps[(6) - (9)].val.opval), (ps[(8) - (9)].val.opval), (ps[(9) - (9)].val.opval)));
 367                           parser->copline = (line_t)(ps[(1) - (9)].val.ival);
 368                         ;}
 369     break;
 370
 371   case 45:
 372 #line 376 "perly.y"
 373     {
 374                           (yyval.opval) = block_end((ps[(4) - (8)].val.ival), newFOROP(0,
 375                                       op_lvalue((ps[(2) - (8)].val.opval), OP_ENTERLOOP), (ps[(5) - (8)].val.opval), (ps[(7) - (8)].val.opval), (ps[(8) - (8)].val.opval)));
 376                           parser->copline = (line_t)(ps[(1) - (8)].val.ival);
 377                         ;}
 378     break;
 379
 380   case 46:
 381 #line 382 "perly.y"
 382     {
 383                           (yyval.opval) = block_end((ps[(3) - (7)].val.ival),
 384                                   newFOROP(0, (OP*)NULL, (ps[(4) - (7)].val.opval), (ps[(6) - (7)].val.opval), (ps[(7) - (7)].val.opval)));
 385                           parser->copline = (line_t)(ps[(1) - (7)].val.ival);
 386                         ;}
 387     break;
 388
 389   case 47:
 390 #line 388 "perly.y"
 391     {
 392                           /* a block is a loop that happens once */
 393                           (yyval.opval) = newWHILEOP(0, 1, (LOOP*)(OP*)NULL,
 394                                   (OP*)NULL, (ps[(1) - (2)].val.opval), (ps[(2) - (2)].val.opval), 0);
 395                         ;}
 396     break;
 397
 398   case 48:
 399 #line 394 "perly.y"
 400     {
 401                           package((ps[(3) - (5)].val.opval));
 402                           if ((ps[(2) - (5)].val.opval)) {
 403                               package_version((ps[(2) - (5)].val.opval));
 404                           }
 405                         ;}
 406     break;
 407
 408   case 49:
 409 #line 401 "perly.y"
 410     {
 411                           /* a block is a loop that happens once */
 412                           (yyval.opval) = newWHILEOP(0, 1, (LOOP*)(OP*)NULL,
 413                                   (OP*)NULL, block_end((ps[(5) - (8)].val.ival), (ps[(7) - (8)].val.opval)), (OP*)NULL, 0);
 414                           if (parser->copline > (line_t)(ps[(4) - (8)].val.ival))
 415                               parser->copline = (line_t)(ps[(4) - (8)].val.ival);
 416                         ;}
 417     break;
 418
 419   case 50:
 420 #line 409 "perly.y"
 421     {
 422                           (yyval.opval) = (ps[(1) - (2)].val.opval);
 423                         ;}
 424     break;
 425
 426   case 51:
 427 #line 413 "perly.y"
 428     {
 429                           (yyval.opval) = (OP*)NULL;
 430                           parser->copline = NOLINE;
 431                         ;}
 432     break;
 433
 434   case 52:
 435 #line 421 "perly.y"
 436     { OP *list;
 437                           if ((ps[(2) - (2)].val.opval)) {
 438                               OP *term = (ps[(2) - (2)].val.opval);
 439                               list = op_append_elem(OP_LIST, (ps[(1) - (2)].val.opval), term);
 440                           }
 441                           else {
 442                               list = (ps[(1) - (2)].val.opval);
 443                           }
 444                           if (parser->copline == NOLINE)
 445                                parser->copline = CopLINE(PL_curcop)-1;
 446                           else parser->copline--;
 447                           (yyval.opval) = newSTATEOP(0, NULL,
 448                                           convert(OP_FORMLINE, 0, list));
 449                         ;}
 450     break;
 451
 452   case 53:
 453 #line 438 "perly.y"
 454     { (yyval.opval) = NULL; ;}
 455     break;
 456
 457   case 54:
 458 #line 440 "perly.y"
 459     { (yyval.opval) = op_unscope((ps[(2) - (3)].val.opval)); ;}
 460     break;
 461
 462   case 55:
 463 #line 445 "perly.y"
 464     { (yyval.opval) = (OP*)NULL; ;}
 465     break;
 466
 467   case 56:
 468 #line 447 "perly.y"
 469     { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
 470     break;
 471
 472   case 57:
 473 #line 449 "perly.y"
 474     { (yyval.opval) = newLOGOP(OP_AND, 0, (ps[(3) - (3)].val.opval), (ps[(1) - (3)].val.opval)); ;}
 475     break;
 476
 477   case 58:
 478 #line 451 "perly.y"
 479     { (yyval.opval) = newLOGOP(OP_OR, 0, (ps[(3) - (3)].val.opval), (ps[(1) - (3)].val.opval)); ;}
 480     break;
 481
 482   case 59:
 483 #line 453 "perly.y"
 484     { (yyval.opval) = newLOOPOP(OPf_PARENS, 1, scalar((ps[(3) - (3)].val.opval)), (ps[(1) - (3)].val.opval)); ;}
 485     break;
 486
 487   case 60:
 488 #line 455 "perly.y"
 489     { (yyval.opval) = newLOOPOP(OPf_PARENS, 1, (ps[(3) - (3)].val.opval), (ps[(1) - (3)].val.opval)); ;}
 490     break;
 491
 492   case 61:
 493 #line 457 "perly.y"
 494     { (yyval.opval) = newFOROP(0, (OP*)NULL, (ps[(3) - (3)].val.opval), (ps[(1) - (3)].val.opval), (OP*)NULL);
 495                           parser->copline = (line_t)(ps[(2) - (3)].val.ival); ;}
 496     break;
 497
 498   case 62:
 499 #line 460 "perly.y"
 500     { (yyval.opval) = newWHENOP((ps[(3) - (3)].val.opval), op_scope((ps[(1) - (3)].val.opval))); ;}
 501     break;
 502
 503   case 63:
 504 #line 465 "perly.y"
 505     { (yyval.opval) = (OP*)NULL; ;}
 506     break;
 507
 508   case 64:
 509 #line 467 "perly.y"
 510     {
 511                           ((ps[(2) - (2)].val.opval))->op_flags |= OPf_PARENS;
 512                           (yyval.opval) = op_scope((ps[(2) - (2)].val.opval));
 513                         ;}
 514     break;
 515
 516   case 65:
 517 #line 472 "perly.y"
 518     { parser->copline = (line_t)(ps[(1) - (6)].val.ival);
 519                             (yyval.opval) = newCONDOP(0,
 520                                 newSTATEOP(OPf_SPECIAL,NULL,(ps[(3) - (6)].val.opval)),
 521                                 op_scope((ps[(5) - (6)].val.opval)), (ps[(6) - (6)].val.opval));
 522                           PL_hints |= HINT_BLOCK_SCOPE;
 523                         ;}
 524     break;
 525
 526   case 66:
 527 #line 482 "perly.y"
 528     { (yyval.opval) = (OP*)NULL; ;}
 529     break;
 530
 531   case 67:
 532 #line 484 "perly.y"
 533     { (yyval.opval) = op_scope((ps[(2) - (2)].val.opval)); ;}
 534     break;
 535
 536   case 68:
 537 #line 489 "perly.y"
 538     { (yyval.ival) = (PL_min_intro_pending &&
 539                             PL_max_intro_pending >=  PL_min_intro_pending);
 540                           intro_my(); ;}
 541     break;
 542
 543   case 69:
 544 #line 495 "perly.y"
 545     { (yyval.opval) = (OP*)NULL; ;}
 546     break;
 547
 548   case 71:
 549 #line 501 "perly.y"
 550     { YYSTYPE tmplval;
 551                           (void)scan_num("1", &tmplval);
 552                           (yyval.opval) = tmplval.opval; ;}
 553     break;
 554
 555   case 73:
 556 #line 509 "perly.y"
 557     { (yyval.opval) = invert(scalar((ps[(1) - (1)].val.opval))); ;}
 558     break;
 559
 560   case 74:
 561 #line 514 "perly.y"
 562     { (yyval.opval) = (ps[(1) - (1)].val.opval); intro_my(); ;}
 563     break;
 564
 565   case 75:
 566 #line 518 "perly.y"
 567     { (yyval.opval) = (ps[(1) - (1)].val.opval); intro_my(); ;}
 568     break;
 569
 570   case 76:
 571 #line 522 "perly.y"
 572     { (yyval.opval) = (ps[(1) - (1)].val.opval); intro_my(); ;}
 573     break;
 574
 575   case 77:
 576 #line 525 "perly.y"
 577     { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
 578     break;
 579
 580   case 78:
 581 #line 526 "perly.y"
 582     { (yyval.opval) = (OP*)NULL; ;}
 583     break;
 584
 585   case 79:
 586 #line 530 "perly.y"
 587     { (yyval.ival) = start_subparse(FALSE, 0);
 588                             SAVEFREESV(PL_compcv); ;}
 589     break;
 590
 591   case 80:
 592 #line 536 "perly.y"
 593     { (yyval.ival) = start_subparse(FALSE, CVf_ANON);
 594                             SAVEFREESV(PL_compcv); ;}
 595     break;
 596
 597   case 81:
 598 #line 541 "perly.y"
 599     { (yyval.ival) = start_subparse(TRUE, 0);
 600                             SAVEFREESV(PL_compcv); ;}
 601     break;
 602
 603   case 84:
 604 #line 552 "perly.y"
 605     { (yyval.opval) = (OP*)NULL; ;}
 606     break;
 607
 608   case 86:
 609 #line 558 "perly.y"
 610     { (yyval.opval) = (OP*)NULL; ;}
 611     break;
 612
 613   case 87:
 614 #line 560 "perly.y"
 615     { (yyval.opval) = (ps[(2) - (2)].val.opval); ;}
 616     break;
 617
 618   case 88:
 619 #line 562 "perly.y"
 620     { (yyval.opval) = (OP*)NULL; ;}
 621     break;
 622
 623   case 89:
 624 #line 567 "perly.y"
 625     { (yyval.opval) = (ps[(2) - (2)].val.opval); ;}
 626     break;
 627
 628   case 90:
 629 #line 569 "perly.y"
 630     { (yyval.opval) = (OP*)NULL; ;}
 631     break;
 632
 633   case 91:
 634 #line 573 "perly.y"
 635     { (yyval.opval) = (OP*)NULL; ;}
 636     break;
 637
 638   case 92:
 639 #line 575 "perly.y"
 640     {
 641                           if (!FEATURE_SIGNATURES_IS_ENABLED)
 642                             Perl_croak(aTHX_ "Experimental "
 643                                 "subroutine signatures not enabled");
 644                           Perl_ck_warner_d(aTHX_
 645                                 packWARN(WARN_EXPERIMENTAL__SIGNATURES),
 646                                 "The signatures feature is experimental");
 647                           (yyval.opval) = parse_subsignature();
 648                         ;}
 649     break;
 650
 651   case 93:
 652 #line 585 "perly.y"
 653     {
 654                           (yyval.opval) = op_append_list(OP_LINESEQ, (ps[(2) - (3)].val.opval),
 655                                 newSTATEOP(0, NULL, sawparens(newNULLLIST())));
 656                           parser->expect = XBLOCK;
 657                         ;}
 658     break;
 659
 660   case 94:
 661 #line 594 "perly.y"
 662     {
 663                           if (parser->copline > (line_t)(ps[(3) - (5)].val.ival))
 664                               parser->copline = (line_t)(ps[(3) - (5)].val.ival);
 665                           (yyval.opval) = block_end((ps[(1) - (5)].val.ival),
 666                                 op_append_list(OP_LINESEQ, (ps[(2) - (5)].val.opval), (ps[(4) - (5)].val.opval)));
 667                         ;}
 668     break;
 669
 670   case 95:
 671 #line 603 "perly.y"
 672     { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
 673     break;
 674
 675   case 96:
 676 #line 604 "perly.y"
 677     { (yyval.opval) = (OP*)NULL; ;}
 678     break;
 679
 680   case 97:
 681 #line 609 "perly.y"
 682     { (yyval.opval) = newLOGOP(OP_AND, 0, (ps[(1) - (3)].val.opval), (ps[(3) - (3)].val.opval)); ;}
 683     break;
 684
 685   case 98:
 686 #line 611 "perly.y"
 687     { (yyval.opval) = newLOGOP((ps[(2) - (3)].val.ival), 0, (ps[(1) - (3)].val.opval), (ps[(3) - (3)].val.opval)); ;}
 688     break;
 689
 690   case 99:
 691 #line 613 "perly.y"
 692     { (yyval.opval) = newLOGOP(OP_DOR, 0, (ps[(1) - (3)].val.opval), (ps[(3) - (3)].val.opval)); ;}
 693     break;
 694
 695   case 101:
 696 #line 619 "perly.y"
 697     { (yyval.opval) = (ps[(1) - (2)].val.opval); ;}
 698     break;
 699
 700   case 102:
 701 #line 621 "perly.y"
 702     {
 703                           OP* term = (ps[(3) - (3)].val.opval);
 704                           (yyval.opval) = op_append_elem(OP_LIST, (ps[(1) - (3)].val.opval), term);
 705                         ;}
 706     break;
 707
 708   case 104:
 709 #line 630 "perly.y"
 710     { (yyval.opval) = convert((ps[(1) - (3)].val.ival), OPf_STACKED,
 711                                 op_prepend_elem(OP_LIST, newGVREF((ps[(1) - (3)].val.ival),(ps[(2) - (3)].val.opval)), (ps[(3) - (3)].val.opval)) );
 712                         ;}
 713     break;
 714
 715   case 105:
 716 #line 634 "perly.y"
 717     { (yyval.opval) = convert((ps[(1) - (5)].val.ival), OPf_STACKED,
 718                                 op_prepend_elem(OP_LIST, newGVREF((ps[(1) - (5)].val.ival),(ps[(3) - (5)].val.opval)), (ps[(4) - (5)].val.opval)) );
 719                         ;}
 720     break;
 721
 722   case 106:
 723 #line 638 "perly.y"
 724     { (yyval.opval) = convert(OP_ENTERSUB, OPf_STACKED,
 725                                 op_append_elem(OP_LIST,
 726                                     op_prepend_elem(OP_LIST, scalar((ps[(1) - (6)].val.opval)), (ps[(5) - (6)].val.opval)),
 727                                     newUNOP(OP_METHOD, 0, (ps[(3) - (6)].val.opval))));
 728                         ;}
 729     break;
 730
 731   case 107:
 732 #line 644 "perly.y"
 733     { (yyval.opval) = convert(OP_ENTERSUB, OPf_STACKED,
 734                                 op_append_elem(OP_LIST, scalar((ps[(1) - (3)].val.opval)),
 735                                     newUNOP(OP_METHOD, 0, (ps[(3) - (3)].val.opval))));
 736                         ;}
 737     break;
 738
 739   case 108:
 740 #line 649 "perly.y"
 741     { (yyval.opval) = convert(OP_ENTERSUB, OPf_STACKED,
 742                                 op_append_elem(OP_LIST,
 743                                     op_prepend_elem(OP_LIST, (ps[(2) - (3)].val.opval), (ps[(3) - (3)].val.opval)),
 744                                     newUNOP(OP_METHOD, 0, (ps[(1) - (3)].val.opval))));
 745                         ;}
 746     break;
 747
 748   case 109:
 749 #line 655 "perly.y"
 750     { (yyval.opval) = convert(OP_ENTERSUB, OPf_STACKED,
 751                                 op_append_elem(OP_LIST,
 752                                     op_prepend_elem(OP_LIST, (ps[(2) - (5)].val.opval), (ps[(4) - (5)].val.opval)),
 753                                     newUNOP(OP_METHOD, 0, (ps[(1) - (5)].val.opval))));
 754                         ;}
 755     break;
 756
 757   case 110:
 758 #line 661 "perly.y"
 759     { (yyval.opval) = convert((ps[(1) - (2)].val.ival), 0, (ps[(2) - (2)].val.opval)); ;}
 760     break;
 761
 762   case 111:
 763 #line 663 "perly.y"
 764     { (yyval.opval) = convert((ps[(1) - (4)].val.ival), 0, (ps[(3) - (4)].val.opval)); ;}
 765     break;
 766
 767   case 112:
 768 #line 665 "perly.y"
 769     { SvREFCNT_inc_simple_void(PL_compcv);
 770                           (yyval.opval) = newANONATTRSUB((ps[(2) - (3)].val.ival), 0, (OP*)NULL, (ps[(3) - (3)].val.opval)); ;}
 771     break;
 772
 773   case 113:
 774 #line 668 "perly.y"
 775     { (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED,
 776                                  op_append_elem(OP_LIST,
 777                                    op_prepend_elem(OP_LIST, (ps[(4) - (5)].val.opval), (ps[(5) - (5)].val.opval)), (ps[(1) - (5)].val.opval)));
 778                         ;}
 779     break;
 780
 781   case 116:
 782 #line 683 "perly.y"
 783     { (yyval.opval) = newBINOP(OP_GELEM, 0, (ps[(1) - (5)].val.opval), scalar((ps[(3) - (5)].val.opval))); ;}
 784     break;
 785
 786   case 117:
 787 #line 685 "perly.y"
 788     { (yyval.opval) = newBINOP(OP_AELEM, 0, oopsAV((ps[(1) - (4)].val.opval)), scalar((ps[(3) - (4)].val.opval)));
 789                         ;}
 790     break;
 791
 792   case 118:
 793 #line 688 "perly.y"
 794     { (yyval.opval) = newBINOP(OP_AELEM, 0,
 795                                         ref(newAVREF((ps[(1) - (5)].val.opval)),OP_RV2AV),
 796                                         scalar((ps[(4) - (5)].val.opval)));
 797                         ;}
 798     break;
 799
 800   case 119:
 801 #line 693 "perly.y"
 802     { (yyval.opval) = newBINOP(OP_AELEM, 0,
 803                                         ref(newAVREF((ps[(1) - (4)].val.opval)),OP_RV2AV),
 804                                         scalar((ps[(3) - (4)].val.opval)));
 805                         ;}
 806     break;
 807
 808   case 120:
 809 #line 698 "perly.y"
 810     { (yyval.opval) = newBINOP(OP_HELEM, 0, oopsHV((ps[(1) - (5)].val.opval)), jmaybe((ps[(3) - (5)].val.opval)));
 811                         ;}
 812     break;
 813
 814   case 121:
 815 #line 701 "perly.y"
 816     { (yyval.opval) = newBINOP(OP_HELEM, 0,
 817                                         ref(newHVREF((ps[(1) - (6)].val.opval)),OP_RV2HV),
 818                                         jmaybe((ps[(4) - (6)].val.opval))); ;}
 819     break;
 820
 821   case 122:
 822 #line 705 "perly.y"
 823     { (yyval.opval) = newBINOP(OP_HELEM, 0,
 824                                         ref(newHVREF((ps[(1) - (5)].val.opval)),OP_RV2HV),
 825                                         jmaybe((ps[(3) - (5)].val.opval))); ;}
 826     break;
 827
 828   case 123:
 829 #line 709 "perly.y"
 830     { (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED,
 831                                    newCVREF(0, scalar((ps[(1) - (4)].val.opval)))); ;}
 832     break;
 833
 834   case 124:
 835 #line 712 "perly.y"
 836     { (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED,
 837                                    op_append_elem(OP_LIST, (ps[(4) - (5)].val.opval),
 838                                        newCVREF(0, scalar((ps[(1) - (5)].val.opval))))); ;}
 839     break;
 840
 841   case 125:
 842 #line 717 "perly.y"
 843     { (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED,
 844                                    op_append_elem(OP_LIST, (ps[(3) - (4)].val.opval),
 845                                                newCVREF(0, scalar((ps[(1) - (4)].val.opval))))); ;}
 846     break;
 847
 848   case 126:
 849 #line 721 "perly.y"
 850     { (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED,
 851                                    newCVREF(0, scalar((ps[(1) - (3)].val.opval)))); ;}
 852     break;
 853
 854   case 127:
 855 #line 724 "perly.y"
 856     { (yyval.opval) = newSLICEOP(0, (ps[(5) - (6)].val.opval), (ps[(2) - (6)].val.opval)); ;}
 857     break;
 858
 859   case 128:
 860 #line 726 "perly.y"
 861     { (yyval.opval) = newSLICEOP(0, (ps[(3) - (4)].val.opval), (ps[(1) - (4)].val.opval)); ;}
 862     break;
 863
 864   case 129:
 865 #line 728 "perly.y"
 866     { (yyval.opval) = newSLICEOP(0, (ps[(4) - (5)].val.opval), (OP*)NULL); ;}
 867     break;
 868
 869   case 130:
 870 #line 733 "perly.y"
 871     { (yyval.opval) = newASSIGNOP(OPf_STACKED, (ps[(1) - (3)].val.opval), (ps[(2) - (3)].val.ival), (ps[(3) - (3)].val.opval)); ;}
 872     break;
 873
 874   case 131:
 875 #line 735 "perly.y"
 876     { (yyval.opval) = newBINOP((ps[(2) - (3)].val.ival), 0, scalar((ps[(1) - (3)].val.opval)), scalar((ps[(3) - (3)].val.opval))); ;}
 877     break;
 878
 879   case 132:
 880 #line 737 "perly.y"
 881     {   if ((ps[(2) - (3)].val.ival) != OP_REPEAT)
 882                                 scalar((ps[(1) - (3)].val.opval));
 883                             (yyval.opval) = newBINOP((ps[(2) - (3)].val.ival), 0, (ps[(1) - (3)].val.opval), scalar((ps[(3) - (3)].val.opval)));
 884                         ;}
 885     break;
 886
 887   case 133:
 888 #line 742 "perly.y"
 889     { (yyval.opval) = newBINOP((ps[(2) - (3)].val.ival), 0, scalar((ps[(1) - (3)].val.opval)), scalar((ps[(3) - (3)].val.opval))); ;}
 890     break;
 891
 892   case 134:
 893 #line 744 "perly.y"
 894     { (yyval.opval) = newBINOP((ps[(2) - (3)].val.ival), 0, scalar((ps[(1) - (3)].val.opval)), scalar((ps[(3) - (3)].val.opval))); ;}
 895     break;
 896
 897   case 135:
 898 #line 746 "perly.y"
 899     { (yyval.opval) = newBINOP((ps[(2) - (3)].val.ival), 0, scalar((ps[(1) - (3)].val.opval)), scalar((ps[(3) - (3)].val.opval))); ;}
 900     break;
 901
 902   case 136:
 903 #line 748 "perly.y"
 904     { (yyval.opval) = newBINOP((ps[(2) - (3)].val.ival), 0, scalar((ps[(1) - (3)].val.opval)), scalar((ps[(3) - (3)].val.opval))); ;}
 905     break;
 906
 907   case 137:
 908 #line 750 "perly.y"
 909     { (yyval.opval) = newBINOP((ps[(2) - (3)].val.ival), 0, scalar((ps[(1) - (3)].val.opval)), scalar((ps[(3) - (3)].val.opval))); ;}
 910     break;
 911
 912   case 138:
 913 #line 752 "perly.y"
 914     { (yyval.opval) = newBINOP((ps[(2) - (3)].val.ival), 0, scalar((ps[(1) - (3)].val.opval)), scalar((ps[(3) - (3)].val.opval))); ;}
 915     break;
 916
 917   case 139:
 918 #line 754 "perly.y"
 919     { (yyval.opval) = newRANGE((ps[(2) - (3)].val.ival), scalar((ps[(1) - (3)].val.opval)), scalar((ps[(3) - (3)].val.opval))); ;}
 920     break;
 921
 922   case 140:
 923 #line 756 "perly.y"
 924     { (yyval.opval) = newLOGOP(OP_AND, 0, (ps[(1) - (3)].val.opval), (ps[(3) - (3)].val.opval)); ;}
 925     break;
 926
 927   case 141:
 928 #line 758 "perly.y"
 929     { (yyval.opval) = newLOGOP(OP_OR, 0, (ps[(1) - (3)].val.opval), (ps[(3) - (3)].val.opval)); ;}
 930     break;
 931
 932   case 142:
 933 #line 760 "perly.y"
 934     { (yyval.opval) = newLOGOP(OP_DOR, 0, (ps[(1) - (3)].val.opval), (ps[(3) - (3)].val.opval)); ;}
 935     break;
 936
 937   case 143:
 938 #line 762 "perly.y"
 939     { (yyval.opval) = bind_match((ps[(2) - (3)].val.ival), (ps[(1) - (3)].val.opval), (ps[(3) - (3)].val.opval)); ;}
 940     break;
 941
 942   case 144:
 943 #line 767 "perly.y"
 944     { (yyval.opval) = newUNOP(OP_NEGATE, 0, scalar((ps[(2) - (2)].val.opval))); ;}
 945     break;
 946
 947   case 145:
 948 #line 769 "perly.y"
 949     { (yyval.opval) = (ps[(2) - (2)].val.opval); ;}
 950     break;
 951
 952   case 146:
 953 #line 772 "perly.y"
 954     { (yyval.opval) = newUNOP(OP_NOT, 0, scalar((ps[(2) - (2)].val.opval))); ;}
 955     break;
 956
 957   case 147:
 958 #line 774 "perly.y"
 959     { (yyval.opval) = newUNOP(OP_COMPLEMENT, 0, scalar((ps[(2) - (2)].val.opval))); ;}
 960     break;
 961
 962   case 148:
 963 #line 776 "perly.y"
 964     { (yyval.opval) = newUNOP(OP_POSTINC, 0,
 965                                         op_lvalue(scalar((ps[(1) - (2)].val.opval)), OP_POSTINC)); ;}
 966     break;
 967
 968   case 149:
 969 #line 779 "perly.y"
 970     { (yyval.opval) = newUNOP(OP_POSTDEC, 0,
 971                                         op_lvalue(scalar((ps[(1) - (2)].val.opval)), OP_POSTDEC));;}
 972     break;
 973
 974   case 150:
 975 #line 782 "perly.y"
 976     { (yyval.opval) = convert(OP_JOIN, 0,
 977                                        op_append_elem(
 978                                         OP_LIST,
 979                                         newSVREF(scalar(
 980                                             newSVOP(OP_CONST,0,
 981                                                     newSVpvs("\""))
 982                                         )),
 983                                         (ps[(1) - (2)].val.opval)
 984                                        ));
 985                         ;}
 986     break;
 987
 988   case 151:
 989 #line 793 "perly.y"
 990     { (yyval.opval) = newUNOP(OP_PREINC, 0,
 991                                         op_lvalue(scalar((ps[(2) - (2)].val.opval)), OP_PREINC)); ;}
 992     break;
 993
 994   case 152:
 995 #line 796 "perly.y"
 996     { (yyval.opval) = newUNOP(OP_PREDEC, 0,
 997                                         op_lvalue(scalar((ps[(2) - (2)].val.opval)), OP_PREDEC)); ;}
 998     break;
 999
1000   case 153:
1001 #line 803 "perly.y"
1002     { (yyval.opval) = newANONLIST((ps[(2) - (3)].val.opval)); ;}
1003     break;
1004
1005   case 154:
1006 #line 805 "perly.y"
1007     { (yyval.opval) = newANONLIST((OP*)NULL);;}
1008     break;
1009
1010   case 155:
1011 #line 807 "perly.y"
1012     { (yyval.opval) = newANONHASH((ps[(2) - (4)].val.opval)); ;}
1013     break;
1014
1015   case 156:
1016 #line 809 "perly.y"
1017     { (yyval.opval) = newANONHASH((OP*)NULL); ;}
1018     break;
1019
1020   case 157:
1021 #line 811 "perly.y"
1022     { SvREFCNT_inc_simple_void(PL_compcv);
1023                           (yyval.opval) = newANONATTRSUB((ps[(2) - (5)].val.ival), (ps[(3) - (5)].val.opval), (ps[(4) - (5)].val.opval), (ps[(5) - (5)].val.opval)); ;}
1024     break;
1025
1026   case 158:
1027 #line 818 "perly.y"
1028     { (yyval.opval) = dofile((ps[(2) - (2)].val.opval), (ps[(1) - (2)].val.ival));;}
1029     break;
1030
1031   case 159:
1032 #line 820 "perly.y"
1033     { (yyval.opval) = newUNOP(OP_NULL, OPf_SPECIAL, op_scope((ps[(2) - (2)].val.opval)));;}
1034     break;
1035
1036   case 164:
1037 #line 828 "perly.y"
1038     { (yyval.opval) = newCONDOP(0, (ps[(1) - (5)].val.opval), (ps[(3) - (5)].val.opval), (ps[(5) - (5)].val.opval)); ;}
1039     break;
1040
1041   case 165:
1042 #line 830 "perly.y"
1043     { (yyval.opval) = newUNOP(OP_REFGEN, 0, op_lvalue((ps[(2) - (2)].val.opval),OP_REFGEN)); ;}
1044     break;
1045
1046   case 166:
1047 #line 832 "perly.y"
1048     { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
1049     break;
1050
1051   case 167:
1052 #line 834 "perly.y"
1053     { (yyval.opval) = localize((ps[(2) - (2)].val.opval),(ps[(1) - (2)].val.ival)); ;}
1054     break;
1055
1056   case 168:
1057 #line 836 "perly.y"
1058     { (yyval.opval) = sawparens((ps[(2) - (3)].val.opval)); ;}
1059     break;
1060
1061   case 169:
1062 #line 838 "perly.y"
1063     { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
1064     break;
1065
1066   case 170:
1067 #line 840 "perly.y"
1068     { (yyval.opval) = sawparens(newNULLLIST()); ;}
1069     break;
1070
1071   case 171:
1072 #line 842 "perly.y"
1073     { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
1074     break;
1075
1076   case 172:
1077 #line 844 "perly.y"
1078     { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
1079     break;
1080
1081   case 173:
1082 #line 846 "perly.y"
1083     { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
1084     break;
1085
1086   case 174:
1087 #line 848 "perly.y"
1088     { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
1089     break;
1090
1091   case 175:
1092 #line 850 "perly.y"
1093     { (yyval.opval) = newUNOP(OP_AV2ARYLEN, 0, ref((ps[(1) - (1)].val.opval), OP_AV2ARYLEN));;}
1094     break;
1095
1096   case 176:
1097 #line 852 "perly.y"
1098     { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
1099     break;
1100
1101   case 177:
1102 #line 854 "perly.y"
1103     { (yyval.opval) = op_prepend_elem(OP_ASLICE,
1104                                 newOP(OP_PUSHMARK, 0),
1105                                     newLISTOP(OP_ASLICE, 0,
1106                                         list((ps[(3) - (4)].val.opval)),
1107                                         ref((ps[(1) - (4)].val.opval), OP_ASLICE)));
1108                           if ((yyval.opval) && (ps[(1) - (4)].val.opval))
1109                               (yyval.opval)->op_private |=
1110                                   (ps[(1) - (4)].val.opval)->op_private & OPpSLICEWARNING;
1111                         ;}
1112     break;
1113
1114   case 178:
1115 #line 864 "perly.y"
1116     { (yyval.opval) = op_prepend_elem(OP_KVASLICE,
1117                                 newOP(OP_PUSHMARK, 0),
1118                                     newLISTOP(OP_KVASLICE, 0,
1119                                         list((ps[(3) - (4)].val.opval)),
1120                                         ref(oopsAV((ps[(1) - (4)].val.opval)), OP_KVASLICE)));
1121                           if ((yyval.opval) && (ps[(1) - (4)].val.opval))
1122                               (yyval.opval)->op_private |=
1123                                   (ps[(1) - (4)].val.opval)->op_private & OPpSLICEWARNING;
1124                         ;}
1125     break;
1126
1127   case 179:
1128 #line 874 "perly.y"
1129     { (yyval.opval) = op_prepend_elem(OP_HSLICE,
1130                                 newOP(OP_PUSHMARK, 0),
1131                                     newLISTOP(OP_HSLICE, 0,
1132                                         list((ps[(3) - (5)].val.opval)),
1133                                         ref(oopsHV((ps[(1) - (5)].val.opval)), OP_HSLICE)));
1134                           if ((yyval.opval) && (ps[(1) - (5)].val.opval))
1135                               (yyval.opval)->op_private |=
1136                                   (ps[(1) - (5)].val.opval)->op_private & OPpSLICEWARNING;
1137                         ;}
1138     break;
1139
1140   case 180:
1141 #line 884 "perly.y"
1142     { (yyval.opval) = op_prepend_elem(OP_KVHSLICE,
1143                                 newOP(OP_PUSHMARK, 0),
1144                                     newLISTOP(OP_KVHSLICE, 0,
1145                                         list((ps[(3) - (5)].val.opval)),
1146                                         ref((ps[(1) - (5)].val.opval), OP_KVHSLICE)));
1147                           if ((yyval.opval) && (ps[(1) - (5)].val.opval))
1148                               (yyval.opval)->op_private |=
1149                                   (ps[(1) - (5)].val.opval)->op_private & OPpSLICEWARNING;
1150                         ;}
1151     break;
1152
1153   case 181:
1154 #line 894 "perly.y"
1155     { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
1156     break;
1157
1158   case 182:
1159 #line 896 "perly.y"
1160     { (yyval.opval) = newUNOP(OP_ENTERSUB, 0, scalar((ps[(1) - (1)].val.opval))); ;}
1161     break;
1162
1163   case 183:
1164 #line 898 "perly.y"
1165     { (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED, scalar((ps[(1) - (3)].val.opval)));
1166                         ;}
1167     break;
1168
1169   case 184:
1170 #line 901 "perly.y"
1171     {
1172                           (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED,
1173                                 op_append_elem(OP_LIST, (ps[(3) - (4)].val.opval), scalar((ps[(1) - (4)].val.opval))));
1174                         ;}
1175     break;
1176
1177   case 185:
1178 #line 906 "perly.y"
1179     { (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED,
1180                             op_append_elem(OP_LIST, (ps[(3) - (3)].val.opval), scalar((ps[(2) - (3)].val.opval))));
1181                         ;}
1182     break;
1183
1184   case 186:
1185 #line 910 "perly.y"
1186     { (yyval.opval) = newSVREF((ps[(1) - (4)].val.opval)); ;}
1187     break;
1188
1189   case 187:
1190 #line 912 "perly.y"
1191     { (yyval.opval) = newAVREF((ps[(1) - (4)].val.opval)); ;}
1192     break;
1193
1194   case 188:
1195 #line 914 "perly.y"
1196     { (yyval.opval) = newHVREF((ps[(1) - (4)].val.opval)); ;}
1197     break;
1198
1199   case 189:
1200 #line 916 "perly.y"
1201     { (yyval.opval) = newUNOP(OP_ENTERSUB, 0,
1202                                        scalar(newCVREF((ps[(3) - (4)].val.ival),(ps[(1) - (4)].val.opval)))); ;}
1203     break;
1204
1205   case 190:
1206 #line 919 "perly.y"
1207     { (yyval.opval) = newGVREF(0,(ps[(1) - (4)].val.opval)); ;}
1208     break;
1209
1210   case 191:
1211 #line 921 "perly.y"
1212     { (yyval.opval) = newOP((ps[(1) - (1)].val.ival), OPf_SPECIAL);
1213                             PL_hints |= HINT_BLOCK_SCOPE; ;}
1214     break;
1215
1216   case 192:
1217 #line 924 "perly.y"
1218     { (yyval.opval) = newLOOPEX((ps[(1) - (2)].val.ival),(ps[(2) - (2)].val.opval)); ;}
1219     break;
1220
1221   case 193:
1222 #line 926 "perly.y"
1223     { (yyval.opval) = newUNOP(OP_NOT, 0, scalar((ps[(2) - (2)].val.opval))); ;}
1224     break;
1225
1226   case 194:
1227 #line 928 "perly.y"
1228     { (yyval.opval) = newOP((ps[(1) - (1)].val.ival), 0); ;}
1229     break;
1230
1231   case 195:
1232 #line 930 "perly.y"
1233     { (yyval.opval) = newUNOP((ps[(1) - (2)].val.ival), 0, (ps[(2) - (2)].val.opval)); ;}
1234     break;
1235
1236   case 196:
1237 #line 932 "perly.y"
1238     { (yyval.opval) = newUNOP((ps[(1) - (2)].val.ival), 0, (ps[(2) - (2)].val.opval)); ;}
1239     break;
1240
1241   case 197:
1242 #line 934 "perly.y"
1243     { (yyval.opval) = newOP(OP_REQUIRE, (ps[(1) - (1)].val.ival) ? OPf_SPECIAL : 0); ;}
1244     break;
1245
1246   case 198:
1247 #line 936 "perly.y"
1248     { (yyval.opval) = newUNOP(OP_REQUIRE, (ps[(1) - (2)].val.ival) ? OPf_SPECIAL : 0, (ps[(2) - (2)].val.opval)); ;}
1249     break;
1250
1251   case 199:
1252 #line 938 "perly.y"
1253     { (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED, scalar((ps[(1) - (1)].val.opval))); ;}
1254     break;
1255
1256   case 200:
1257 #line 940 "perly.y"
1258     { (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED,
1259                             op_append_elem(OP_LIST, (ps[(2) - (2)].val.opval), scalar((ps[(1) - (2)].val.opval)))); ;}
1260     break;
1261
1262   case 201:
1263 #line 943 "perly.y"
1264     { (yyval.opval) = newOP((ps[(1) - (1)].val.ival), 0); ;}
1265     break;
1266
1267   case 202:
1268 #line 945 "perly.y"
1269     { (yyval.opval) = newOP((ps[(1) - (3)].val.ival), 0);;}
1270     break;
1271
1272   case 203:
1273 #line 947 "perly.y"
1274     { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
1275     break;
1276
1277   case 204:
1278 #line 949 "perly.y"
1279     { (yyval.opval) = (ps[(1) - (3)].val.opval); ;}
1280     break;
1281
1282   case 205:
1283 #line 951 "perly.y"
1284     { (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED, scalar((ps[(1) - (1)].val.opval))); ;}
1285     break;
1286
1287   case 206:
1288 #line 953 "perly.y"
1289     { (yyval.opval) = ((ps[(1) - (3)].val.ival) == OP_NOT)
1290                           ? newUNOP((ps[(1) - (3)].val.ival), 0, newSVOP(OP_CONST, 0, newSViv(0)))
1291                           : newOP((ps[(1) - (3)].val.ival), OPf_SPECIAL); ;}
1292     break;
1293
1294   case 207:
1295 #line 957 "perly.y"
1296     { (yyval.opval) = newUNOP((ps[(1) - (4)].val.ival), 0, (ps[(3) - (4)].val.opval)); ;}
1297     break;
1298
1299   case 208:
1300 #line 959 "perly.y"
1301     {
1302                             if (   (ps[(1) - (1)].val.opval)->op_type != OP_TRANS
1303                                 && (ps[(1) - (1)].val.opval)->op_type != OP_TRANSR
1304                                 && (((PMOP*)(ps[(1) - (1)].val.opval))->op_pmflags & PMf_HAS_CV))
1305                             {
1306                                 (yyval.ival) = start_subparse(FALSE, CVf_ANON);
1307                                 SAVEFREESV(PL_compcv);
1308                             } else
1309                                 (yyval.ival) = 0;
1310                         ;}
1311     break;
1312
1313   case 209:
1314 #line 970 "perly.y"
1315     { (yyval.opval) = pmruntime((ps[(1) - (5)].val.opval), (ps[(4) - (5)].val.opval), 1, (ps[(2) - (5)].val.ival)); ;}
1316     break;
1317
1318   case 212:
1319 #line 974 "perly.y"
1320     {
1321                           (yyval.opval) = newLISTOP(OP_DIE, 0, newOP(OP_PUSHMARK, 0),
1322                                 newSVOP(OP_CONST, 0, newSVpvs("Unimplemented")));
1323                         ;}
1324     break;
1325
1326   case 214:
1327 #line 983 "perly.y"
1328     { (yyval.opval) = my_attrs((ps[(2) - (3)].val.opval),(ps[(3) - (3)].val.opval)); ;}
1329     break;
1330
1331   case 215:
1332 #line 985 "perly.y"
1333     { (yyval.opval) = localize((ps[(2) - (2)].val.opval),(ps[(1) - (2)].val.ival)); ;}
1334     break;
1335
1336   case 216:
1337 #line 990 "perly.y"
1338     { (yyval.opval) = sawparens((ps[(2) - (3)].val.opval)); ;}
1339     break;
1340
1341   case 217:
1342 #line 992 "perly.y"
1343     { (yyval.opval) = sawparens(newNULLLIST()); ;}
1344     break;
1345
1346   case 218:
1347 #line 995 "perly.y"
1348     { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
1349     break;
1350
1351   case 219:
1352 #line 997 "perly.y"
1353     { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
1354     break;
1355
1356   case 220:
1357 #line 999 "perly.y"
1358     { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
1359     break;
1360
1361   case 221:
1362 #line 1004 "perly.y"
1363     { (yyval.opval) = (OP*)NULL; ;}
1364     break;
1365
1366   case 222:
1367 #line 1006 "perly.y"
1368     { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
1369     break;
1370
1371   case 223:
1372 #line 1010 "perly.y"
1373     { (yyval.opval) = (OP*)NULL; ;}
1374     break;
1375
1376   case 224:
1377 #line 1012 "perly.y"
1378     { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
1379     break;
1380
1381   case 225:
1382 #line 1018 "perly.y"
1383     { parser->in_my = 0; (yyval.opval) = my((ps[(1) - (1)].val.opval)); ;}
1384     break;
1385
1386   case 226:
1387 #line 1022 "perly.y"
1388     { (yyval.opval) = newCVREF((ps[(1) - (2)].val.ival),(ps[(2) - (2)].val.opval)); ;}
1389     break;
1390
1391   case 227:
1392 #line 1026 "perly.y"
1393     { (yyval.opval) = newSVREF((ps[(2) - (2)].val.opval)); ;}
1394     break;
1395
1396   case 228:
1397 #line 1030 "perly.y"
1398     { (yyval.opval) = newAVREF((ps[(2) - (2)].val.opval));
1399                           if ((yyval.opval)) (yyval.opval)->op_private |= (ps[(1) - (2)].val.ival);
1400                         ;}
1401     break;
1402
1403   case 229:
1404 #line 1036 "perly.y"
1405     { (yyval.opval) = newHVREF((ps[(2) - (2)].val.opval));
1406                           if ((yyval.opval)) (yyval.opval)->op_private |= (ps[(1) - (2)].val.ival);
1407                         ;}
1408     break;
1409
1410   case 230:
1411 #line 1042 "perly.y"
1412     { (yyval.opval) = newAVREF((ps[(2) - (2)].val.opval)); ;}
1413     break;
1414
1415   case 231:
1416 #line 1044 "perly.y"
1417     { (yyval.opval) = newAVREF((ps[(1) - (4)].val.opval)); ;}
1418     break;
1419
1420   case 232:
1421 #line 1048 "perly.y"
1422     { (yyval.opval) = newGVREF(0,(ps[(2) - (2)].val.opval)); ;}
1423     break;
1424
1425   case 234:
1426 #line 1053 "perly.y"
1427     { (yyval.opval) = newAVREF((ps[(1) - (3)].val.opval)); ;}
1428     break;
1429
1430   case 236:
1431 #line 1058 "perly.y"
1432     { (yyval.opval) = newHVREF((ps[(1) - (3)].val.opval)); ;}
1433     break;
1434
1435   case 238:
1436 #line 1063 "perly.y"
1437     { (yyval.opval) = newGVREF(0,(ps[(1) - (3)].val.opval)); ;}
1438     break;
1439
1440   case 239:
1441 #line 1068 "perly.y"
1442     { (yyval.opval) = scalar((ps[(1) - (1)].val.opval)); ;}
1443     break;
1444
1445   case 240:
1446 #line 1070 "perly.y"
1447     { (yyval.opval) = scalar((ps[(1) - (1)].val.opval)); ;}
1448     break;
1449
1450   case 241:
1451 #line 1072 "perly.y"
1452     { (yyval.opval) = op_scope((ps[(1) - (1)].val.opval)); ;}
1453     break;
1454
1455   case 242:
1456 #line 1075 "perly.y"
1457     { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
1458     break;
1459
1460
1461 /* Line 1267 of yacc.c.  */
1462
1463       default: break;
1464
1465
1466 /* Generated from:
1467  * 39b6174c4729deec2a6ee4698d7dcd6496acb0a8f063daf726d1f853d4dcb54e perly.y
1468  * d1d4df7b8e30ac9dede664af9179e6e5e7ddc7f2ad9c4eff9e2e5b32c9e16a6e regen_perly.pl
1469  * ex: set ro: */