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