perly.act

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