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