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