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