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 140 "perly.y"
   9     {
  10                           parser->expect = XSTATE;
  11                           (yyval.ival) = 0;
  12                         }
  13
  14     break;
  15
  16   case 3:
  17 #line 145 "perly.y"
  18     {
  19                           newPROG(block_end((ps[-1].val.ival),(ps[0].val.opval)));
  20                           PL_compiling.cop_seq = 0;
  21                           (yyval.ival) = 0;
  22                         }
  23
  24     break;
  25
  26   case 4:
  27 #line 151 "perly.y"
  28     {
  29                           parser->expect = XTERM;
  30                           (yyval.ival) = 0;
  31                         }
  32
  33     break;
  34
  35   case 5:
  36 #line 156 "perly.y"
  37     {
  38                           PL_eval_root = (ps[0].val.opval);
  39                           (yyval.ival) = 0;
  40                         }
  41
  42     break;
  43
  44   case 6:
  45 #line 161 "perly.y"
  46     {
  47                           parser->expect = XBLOCK;
  48                           (yyval.ival) = 0;
  49                         }
  50
  51     break;
  52
  53   case 7:
  54 #line 166 "perly.y"
  55     {
  56                           PL_pad_reset_pending = TRUE;
  57                           PL_eval_root = (ps[0].val.opval);
  58                           (yyval.ival) = 0;
  59                           yyunlex();
  60                           parser->yychar = yytoken = YYEOF;
  61                         }
  62
  63     break;
  64
  65   case 8:
  66 #line 174 "perly.y"
  67     {
  68                           parser->expect = XSTATE;
  69                           (yyval.ival) = 0;
  70                         }
  71
  72     break;
  73
  74   case 9:
  75 #line 179 "perly.y"
  76     {
  77                           PL_pad_reset_pending = TRUE;
  78                           PL_eval_root = (ps[0].val.opval);
  79                           (yyval.ival) = 0;
  80                           yyunlex();
  81                           parser->yychar = yytoken = YYEOF;
  82                         }
  83
  84     break;
  85
  86   case 10:
  87 #line 187 "perly.y"
  88     {
  89                           parser->expect = XSTATE;
  90                           (yyval.ival) = 0;
  91                         }
  92
  93     break;
  94
  95   case 11:
  96 #line 192 "perly.y"
  97     {
  98                           PL_pad_reset_pending = TRUE;
  99                           PL_eval_root = (ps[0].val.opval);
 100                           (yyval.ival) = 0;
 101                           yyunlex();
 102                           parser->yychar = yytoken = YYEOF;
 103                         }
 104
 105     break;
 106
 107   case 12:
 108 #line 200 "perly.y"
 109     {
 110                           parser->expect = XSTATE;
 111                           (yyval.ival) = 0;
 112                         }
 113
 114     break;
 115
 116   case 13:
 117 #line 205 "perly.y"
 118     {
 119                           PL_eval_root = (ps[0].val.opval);
 120                           (yyval.ival) = 0;
 121                         }
 122
 123     break;
 124
 125   case 14:
 126 #line 210 "perly.y"
 127     {
 128                           parser->expect = XSTATE;
 129                           (yyval.ival) = 0;
 130                         }
 131
 132     break;
 133
 134   case 15:
 135 #line 215 "perly.y"
 136     {
 137                           PL_eval_root = (ps[0].val.opval);
 138                           (yyval.ival) = 0;
 139                         }
 140
 141     break;
 142
 143   case 16:
 144 #line 223 "perly.y"
 145     { if (parser->copline > (line_t)(ps[-3].val.ival))
 146                               parser->copline = (line_t)(ps[-3].val.ival);
 147                           (yyval.opval) = block_end((ps[-2].val.ival), (ps[-1].val.opval));
 148                         }
 149
 150     break;
 151
 152   case 17:
 153 #line 230 "perly.y"
 154     { (yyval.opval) = NULL; }
 155
 156     break;
 157
 158   case 18:
 159 #line 235 "perly.y"
 160     { if (parser->copline > (line_t)(ps[-6].val.ival))
 161                               parser->copline = (line_t)(ps[-6].val.ival);
 162                           (yyval.opval) = block_end((ps[-5].val.ival), (ps[-2].val.opval));
 163                         }
 164
 165     break;
 166
 167   case 19:
 168 #line 242 "perly.y"
 169     { (yyval.ival) = block_start(TRUE);
 170                           parser->parsed_sub = 0; }
 171
 172     break;
 173
 174   case 20:
 175 #line 247 "perly.y"
 176     { if (parser->copline > (line_t)(ps[-3].val.ival))
 177                               parser->copline = (line_t)(ps[-3].val.ival);
 178                           (yyval.opval) = block_end((ps[-2].val.ival), (ps[-1].val.opval));
 179                         }
 180
 181     break;
 182
 183   case 21:
 184 #line 254 "perly.y"
 185     { (yyval.ival) = block_start(FALSE);
 186                           parser->parsed_sub = 0; }
 187
 188     break;
 189
 190   case 23:
 191 #line 262 "perly.y"
 192     {   (yyval.opval) = op_append_list(OP_LINESEQ, (ps[-1].val.opval), (ps[0].val.opval));
 193                             PL_pad_reset_pending = TRUE;
 194                             if ((ps[-1].val.opval) && (ps[0].val.opval))
 195                                 PL_hints |= HINT_BLOCK_SCOPE;
 196                         }
 197
 198     break;
 199
 200   case 25:
 201 #line 273 "perly.y"
 202     {   (yyval.opval) = op_append_list(OP_LINESEQ, (ps[-1].val.opval), (ps[0].val.opval));
 203                             PL_pad_reset_pending = TRUE;
 204                             if ((ps[-1].val.opval) && (ps[0].val.opval))
 205                                 PL_hints |= HINT_BLOCK_SCOPE;
 206                         }
 207
 208     break;
 209
 210   case 26:
 211 #line 282 "perly.y"
 212     {
 213                           (yyval.opval) = (ps[0].val.opval) ? newSTATEOP(0, NULL, (ps[0].val.opval)) : NULL;
 214                         }
 215
 216     break;
 217
 218   case 27:
 219 #line 286 "perly.y"
 220     { (yyval.opval) = (ps[0].val.opval); }
 221
 222     break;
 223
 224   case 28:
 225 #line 290 "perly.y"
 226     {
 227                           SV *label = cSVOPx_sv((ps[-1].val.opval));
 228                           (yyval.opval) = newSTATEOP(SvFLAGS(label) & SVf_UTF8,
 229                                             savepv(SvPVX_const(label)), (ps[0].val.opval));
 230                           op_free((ps[-1].val.opval));
 231                         }
 232
 233     break;
 234
 235   case 29:
 236 #line 297 "perly.y"
 237     {
 238                           SV *label = cSVOPx_sv((ps[-1].val.opval));
 239                           (yyval.opval) = newSTATEOP(SvFLAGS(label) & SVf_UTF8,
 240                                             savepv(SvPVX_const(label)), (ps[0].val.opval));
 241                           op_free((ps[-1].val.opval));
 242                         }
 243
 244     break;
 245
 246   case 30:
 247 #line 307 "perly.y"
 248     { (yyval.opval) = (ps[0].val.opval); }
 249
 250     break;
 251
 252   case 31:
 253 #line 309 "perly.y"
 254     {
 255                           CV *fmtcv = PL_compcv;
 256                           newFORM((ps[-2].val.ival), (ps[-1].val.opval), (ps[0].val.opval));
 257                           (yyval.opval) = NULL;
 258                           if (CvOUTSIDE(fmtcv) && !CvEVAL(CvOUTSIDE(fmtcv))) {
 259                               pad_add_weakref(fmtcv);
 260                           }
 261                           parser->parsed_sub = 1;
 262                         }
 263
 264     break;
 265
 266   case 32:
 267 #line 321 "perly.y"
 268     {
 269                           init_named_cv(PL_compcv, (ps[-1].val.opval));
 270                           parser->in_my = 0;
 271                           parser->in_my_stash = NULL;
 272                         }
 273
 274     break;
 275
 276   case 33:
 277 #line 327 "perly.y"
 278     {
 279                           SvREFCNT_inc_simple_void(PL_compcv);
 280                           (ps[-5].val.opval)->op_type == OP_CONST
 281                               ? newATTRSUB((ps[-4].val.ival), (ps[-5].val.opval), (ps[-2].val.opval), (ps[-1].val.opval), (ps[0].val.opval))
 282                               : newMYSUB((ps[-4].val.ival), (ps[-5].val.opval), (ps[-2].val.opval), (ps[-1].val.opval), (ps[0].val.opval))
 283                           ;
 284                           (yyval.opval) = NULL;
 285                           intro_my();
 286                           parser->parsed_sub = 1;
 287                         }
 288
 289     break;
 290
 291   case 34:
 292 #line 342 "perly.y"
 293     {
 294                           init_named_cv(PL_compcv, (ps[-1].val.opval));
 295                           parser->in_my = 0;
 296                           parser->in_my_stash = NULL;
 297                         }
 298
 299     break;
 300
 301   case 35:
 302 #line 348 "perly.y"
 303     {
 304                           SvREFCNT_inc_simple_void(PL_compcv);
 305                           (ps[-4].val.opval)->op_type == OP_CONST
 306                               ? newATTRSUB((ps[-3].val.ival), (ps[-4].val.opval), NULL, (ps[-1].val.opval), (ps[0].val.opval))
 307                               : newMYSUB(  (ps[-3].val.ival), (ps[-4].val.opval), NULL, (ps[-1].val.opval), (ps[0].val.opval))
 308                           ;
 309                           (yyval.opval) = NULL;
 310                           intro_my();
 311                           parser->parsed_sub = 1;
 312                         }
 313
 314     break;
 315
 316   case 36:
 317 #line 359 "perly.y"
 318     {
 319                           package((ps[-1].val.opval));
 320                           if ((ps[-2].val.opval))
 321                               package_version((ps[-2].val.opval));
 322                           (yyval.opval) = NULL;
 323                         }
 324
 325     break;
 326
 327   case 37:
 328 #line 366 "perly.y"
 329     { CvSPECIAL_on(PL_compcv); /* It's a BEGIN {} */ }
 330
 331     break;
 332
 333   case 38:
 334 #line 368 "perly.y"
 335     {
 336                           SvREFCNT_inc_simple_void(PL_compcv);
 337                           utilize((ps[-6].val.ival), (ps[-5].val.ival), (ps[-3].val.opval), (ps[-2].val.opval), (ps[-1].val.opval));
 338                           parser->parsed_sub = 1;
 339                           (yyval.opval) = NULL;
 340                         }
 341
 342     break;
 343
 344   case 39:
 345 #line 375 "perly.y"
 346     {
 347                           (yyval.opval) = block_end((ps[-4].val.ival),
 348                               newCONDOP(0, (ps[-3].val.opval), op_scope((ps[-1].val.opval)), (ps[0].val.opval)));
 349                           parser->copline = (line_t)(ps[-6].val.ival);
 350                         }
 351
 352     break;
 353
 354   case 40:
 355 #line 381 "perly.y"
 356     {
 357                           (yyval.opval) = block_end((ps[-4].val.ival),
 358                               newCONDOP(0, (ps[-3].val.opval), (ps[0].val.opval), op_scope((ps[-1].val.opval))));
 359                           parser->copline = (line_t)(ps[-6].val.ival);
 360                         }
 361
 362     break;
 363
 364   case 41:
 365 #line 387 "perly.y"
 366     {
 367                           (yyval.opval) = block_end((ps[-3].val.ival), newGIVENOP((ps[-2].val.opval), op_scope((ps[0].val.opval)), 0));
 368                           parser->copline = (line_t)(ps[-5].val.ival);
 369                         }
 370
 371     break;
 372
 373   case 42:
 374 #line 392 "perly.y"
 375     { (yyval.opval) = block_end((ps[-3].val.ival), newWHENOP((ps[-2].val.opval), op_scope((ps[0].val.opval)))); }
 376
 377     break;
 378
 379   case 43:
 380 #line 394 "perly.y"
 381     { (yyval.opval) = newWHENOP(0, op_scope((ps[0].val.opval))); }
 382
 383     break;
 384
 385   case 44:
 386 #line 396 "perly.y"
 387     {
 388                           (yyval.opval) = block_end((ps[-5].val.ival),
 389                                   newWHILEOP(0, 1, NULL,
 390                                       (ps[-4].val.opval), (ps[-1].val.opval), (ps[0].val.opval), (ps[-2].val.ival)));
 391                           parser->copline = (line_t)(ps[-7].val.ival);
 392                         }
 393
 394     break;
 395
 396   case 45:
 397 #line 403 "perly.y"
 398     {
 399                           (yyval.opval) = block_end((ps[-5].val.ival),
 400                                   newWHILEOP(0, 1, NULL,
 401                                       (ps[-4].val.opval), (ps[-1].val.opval), (ps[0].val.opval), (ps[-2].val.ival)));
 402                           parser->copline = (line_t)(ps[-7].val.ival);
 403                         }
 404
 405     break;
 406
 407   case 46:
 408 #line 410 "perly.y"
 409     { parser->expect = XTERM; }
 410
 411     break;
 412
 413   case 47:
 414 #line 412 "perly.y"
 415     { parser->expect = XTERM; }
 416
 417     break;
 418
 419   case 48:
 420 #line 415 "perly.y"
 421     {
 422                           OP *initop = (ps[-9].val.opval);
 423                           OP *forop = newWHILEOP(0, 1, NULL,
 424                                       scalar((ps[-6].val.opval)), (ps[0].val.opval), (ps[-2].val.opval), (ps[-3].val.ival));
 425                           if (initop) {
 426                               forop = op_prepend_elem(OP_LINESEQ, initop,
 427                                   op_append_elem(OP_LINESEQ,
 428                                       newOP(OP_UNSTACK, OPf_SPECIAL),
 429                                       forop));
 430                           }
 431                           PL_hints |= HINT_BLOCK_SCOPE;
 432                           (yyval.opval) = block_end((ps[-10].val.ival), forop);
 433                           parser->copline = (line_t)(ps[-12].val.ival);
 434                         }
 435
 436     break;
 437
 438   case 49:
 439 #line 430 "perly.y"
 440     {
 441                           (yyval.opval) = block_end((ps[-6].val.ival), newFOROP(0, (ps[-5].val.opval), (ps[-3].val.opval), (ps[-1].val.opval), (ps[0].val.opval)));
 442                           parser->copline = (line_t)(ps[-8].val.ival);
 443                         }
 444
 445     break;
 446
 447   case 50:
 448 #line 435 "perly.y"
 449     {
 450                           (yyval.opval) = block_end((ps[-8].val.ival), newFOROP(0, (ps[-6].val.opval), (ps[-3].val.opval), (ps[-1].val.opval), (ps[0].val.opval)));
 451                           parser->copline = (line_t)(ps[-10].val.ival);
 452                         }
 453
 454     break;
 455
 456   case 51:
 457 #line 440 "perly.y"
 458     {
 459                           (yyval.opval) = block_end((ps[-4].val.ival), newFOROP(0,
 460                                       op_lvalue((ps[-6].val.opval), OP_ENTERLOOP), (ps[-3].val.opval), (ps[-1].val.opval), (ps[0].val.opval)));
 461                           parser->copline = (line_t)(ps[-7].val.ival);
 462                         }
 463
 464     break;
 465
 466   case 52:
 467 #line 446 "perly.y"
 468     { parser->in_my = 0; (yyval.opval) = my((ps[0].val.opval)); }
 469
 470     break;
 471
 472   case 53:
 473 #line 448 "perly.y"
 474     {
 475                           (yyval.opval) = block_end(
 476                                 (ps[-7].val.ival),
 477                                 newFOROP(0,
 478                                          op_lvalue(
 479                                             newUNOP(OP_REFGEN, 0,
 480                                                     (ps[-5].val.opval)),
 481                                             OP_ENTERLOOP),
 482                                          (ps[-3].val.opval), (ps[-1].val.opval), (ps[0].val.opval))
 483                           );
 484                           parser->copline = (line_t)(ps[-9].val.ival);
 485                         }
 486
 487     break;
 488
 489   case 54:
 490 #line 461 "perly.y"
 491     {
 492                           (yyval.opval) = block_end((ps[-4].val.ival), newFOROP(
 493                                 0, op_lvalue(newUNOP(OP_REFGEN, 0,
 494                                                      (ps[-6].val.opval)),
 495                                              OP_ENTERLOOP), (ps[-3].val.opval), (ps[-1].val.opval), (ps[0].val.opval)));
 496                           parser->copline = (line_t)(ps[-8].val.ival);
 497                         }
 498
 499     break;
 500
 501   case 55:
 502 #line 469 "perly.y"
 503     {
 504                           (yyval.opval) = block_end((ps[-4].val.ival),
 505                                   newFOROP(0, NULL, (ps[-3].val.opval), (ps[-1].val.opval), (ps[0].val.opval)));
 506                           parser->copline = (line_t)(ps[-6].val.ival);
 507                         }
 508
 509     break;
 510
 511   case 56:
 512 #line 475 "perly.y"
 513     { parser->in_my = 1; }
 514
 515     break;
 516
 517   case 57:
 518 #line 477 "perly.y"
 519     { parser->in_my = 0; intro_my(); }
 520
 521     break;
 522
 523   case 58:
 524 #line 479 "perly.y"
 525     {
 526                           (yyval.opval) = newTRYCATCHOP(0,
 527                                   (ps[-9].val.opval), (ps[-4].val.opval), block_end((ps[-5].val.ival), op_scope((ps[-1].val.opval))));
 528                           if((ps[0].val.opval))
 529                               (yyval.opval) = op_wrap_finally((yyval.opval), (ps[0].val.opval));
 530                           parser->copline = (line_t)(ps[-10].val.ival);
 531                         }
 532
 533     break;
 534
 535   case 59:
 536 #line 487 "perly.y"
 537     {
 538                           /* a block is a loop that happens once */
 539                           (yyval.opval) = newWHILEOP(0, 1, NULL,
 540                                   NULL, (ps[-1].val.opval), (ps[0].val.opval), 0);
 541                         }
 542
 543     break;
 544
 545   case 60:
 546 #line 493 "perly.y"
 547     {
 548                           package((ps[-2].val.opval));
 549                           if ((ps[-3].val.opval)) {
 550                               package_version((ps[-3].val.opval));
 551                           }
 552                         }
 553
 554     break;
 555
 556   case 61:
 557 #line 500 "perly.y"
 558     {
 559                           /* a block is a loop that happens once */
 560                           (yyval.opval) = newWHILEOP(0, 1, NULL,
 561                                   NULL, block_end((ps[-3].val.ival), (ps[-1].val.opval)), NULL, 0);
 562                           if (parser->copline > (line_t)(ps[-4].val.ival))
 563                               parser->copline = (line_t)(ps[-4].val.ival);
 564                         }
 565
 566     break;
 567
 568   case 62:
 569 #line 508 "perly.y"
 570     {
 571                           (yyval.opval) = (ps[-1].val.opval);
 572                         }
 573
 574     break;
 575
 576   case 63:
 577 #line 512 "perly.y"
 578     {
 579                           (yyval.opval) = newDEFEROP(0, op_scope((ps[0].val.opval)));
 580                         }
 581
 582     break;
 583
 584   case 64:
 585 #line 516 "perly.y"
 586     {
 587                           (yyval.opval) = newLISTOP(OP_DIE, 0, newOP(OP_PUSHMARK, 0),
 588                                 newSVOP(OP_CONST, 0, newSVpvs("Unimplemented")));
 589                         }
 590
 591     break;
 592
 593   case 65:
 594 #line 521 "perly.y"
 595     {
 596                           (yyval.opval) = NULL;
 597                           parser->copline = NOLINE;
 598                         }
 599
 600     break;
 601
 602   case 66:
 603 #line 529 "perly.y"
 604     { OP *list;
 605                           if ((ps[0].val.opval)) {
 606                               OP *term = (ps[0].val.opval);
 607                               list = op_append_elem(OP_LIST, (ps[-1].val.opval), term);
 608                           }
 609                           else {
 610                               list = (ps[-1].val.opval);
 611                           }
 612                           if (parser->copline == NOLINE)
 613                                parser->copline = CopLINE(PL_curcop)-1;
 614                           else parser->copline--;
 615                           (yyval.opval) = newSTATEOP(0, NULL,
 616                                           op_convert_list(OP_FORMLINE, 0, list));
 617                         }
 618
 619     break;
 620
 621   case 68:
 622 #line 548 "perly.y"
 623     { (yyval.opval) = op_unscope((ps[-1].val.opval)); }
 624
 625     break;
 626
 627   case 70:
 628 #line 556 "perly.y"
 629     { (yyval.opval) = NULL; }
 630
 631     break;
 632
 633   case 71:
 634 #line 558 "perly.y"
 635     { (yyval.opval) = (ps[0].val.opval); }
 636
 637     break;
 638
 639   case 72:
 640 #line 560 "perly.y"
 641     { (yyval.opval) = newLOGOP(OP_AND, 0, (ps[0].val.opval), (ps[-2].val.opval)); }
 642
 643     break;
 644
 645   case 73:
 646 #line 562 "perly.y"
 647     { (yyval.opval) = newLOGOP(OP_OR, 0, (ps[0].val.opval), (ps[-2].val.opval)); }
 648
 649     break;
 650
 651   case 74:
 652 #line 564 "perly.y"
 653     { (yyval.opval) = newLOOPOP(OPf_PARENS, 1, scalar((ps[0].val.opval)), (ps[-2].val.opval)); }
 654
 655     break;
 656
 657   case 75:
 658 #line 566 "perly.y"
 659     { (yyval.opval) = newLOOPOP(OPf_PARENS, 1, (ps[0].val.opval), (ps[-2].val.opval)); }
 660
 661     break;
 662
 663   case 76:
 664 #line 568 "perly.y"
 665     { (yyval.opval) = newFOROP(0, NULL, (ps[0].val.opval), (ps[-2].val.opval), NULL);
 666                           parser->copline = (line_t)(ps[-1].val.ival); }
 667
 668     break;
 669
 670   case 77:
 671 #line 571 "perly.y"
 672     { (yyval.opval) = newWHENOP((ps[0].val.opval), op_scope((ps[-2].val.opval))); }
 673
 674     break;
 675
 676   case 79:
 677 #line 578 "perly.y"
 678     {
 679                           ((ps[0].val.opval))->op_flags |= OPf_PARENS;
 680                           (yyval.opval) = op_scope((ps[0].val.opval));
 681                         }
 682
 683     break;
 684
 685   case 80:
 686 #line 583 "perly.y"
 687     { parser->copline = (line_t)(ps[-5].val.ival);
 688                             (yyval.opval) = newCONDOP(0,
 689                                 newSTATEOP(OPf_SPECIAL,NULL,(ps[-3].val.opval)),
 690                                 op_scope((ps[-1].val.opval)), (ps[0].val.opval));
 691                           PL_hints |= HINT_BLOCK_SCOPE;
 692                         }
 693
 694     break;
 695
 696   case 82:
 697 #line 595 "perly.y"
 698     { (yyval.opval) = op_scope((ps[0].val.opval)); }
 699
 700     break;
 701
 702   case 83:
 703 #line 600 "perly.y"
 704     { (yyval.opval) = NULL; }
 705
 706     break;
 707
 708   case 84:
 709 #line 602 "perly.y"
 710     { (yyval.opval) = op_scope((ps[0].val.opval)); }
 711
 712     break;
 713
 714   case 85:
 715 #line 607 "perly.y"
 716     { (yyval.ival) = (PL_min_intro_pending &&
 717                             PL_max_intro_pending >=  PL_min_intro_pending);
 718                           intro_my(); }
 719
 720     break;
 721
 722   case 88:
 723 #line 619 "perly.y"
 724     { YYSTYPE tmplval;
 725                           (void)scan_num("1", &tmplval);
 726                           (yyval.opval) = tmplval.opval; }
 727
 728     break;
 729
 730   case 90:
 731 #line 627 "perly.y"
 732     { (yyval.opval) = invert(scalar((ps[0].val.opval))); }
 733
 734     break;
 735
 736   case 91:
 737 #line 632 "perly.y"
 738     { (yyval.opval) = (ps[0].val.opval); intro_my(); }
 739
 740     break;
 741
 742   case 92:
 743 #line 636 "perly.y"
 744     { (yyval.opval) = (ps[0].val.opval); intro_my(); }
 745
 746     break;
 747
 748   case 93:
 749 #line 639 "perly.y"
 750     { (yyval.opval) = (ps[0].val.opval); }
 751
 752     break;
 753
 754   case 95:
 755 #line 644 "perly.y"
 756     { (yyval.ival) = start_subparse(FALSE, 0);
 757                             SAVEFREESV(PL_compcv); }
 758
 759     break;
 760
 761   case 96:
 762 #line 650 "perly.y"
 763     { (yyval.ival) = start_subparse(FALSE, CVf_ANON);
 764                             SAVEFREESV(PL_compcv); }
 765
 766     break;
 767
 768   case 97:
 769 #line 655 "perly.y"
 770     { (yyval.ival) = start_subparse(TRUE, 0);
 771                             SAVEFREESV(PL_compcv); }
 772
 773     break;
 774
 775   case 103:
 776 #line 674 "perly.y"
 777     { (yyval.opval) = (ps[0].val.opval); }
 778
 779     break;
 780
 781   case 104:
 782 #line 676 "perly.y"
 783     { (yyval.opval) = NULL; }
 784
 785     break;
 786
 787   case 105:
 788 #line 681 "perly.y"
 789     { (yyval.opval) = (ps[0].val.opval); }
 790
 791     break;
 792
 793   case 106:
 794 #line 683 "perly.y"
 795     { (yyval.opval) = NULL; }
 796
 797     break;
 798
 799   case 107:
 800 #line 694 "perly.y"
 801     { parser->in_my = 0; (yyval.opval) = NULL; }
 802
 803     break;
 804
 805   case 108:
 806 #line 696 "perly.y"
 807     { parser->in_my = 0; (yyval.opval) = (ps[0].val.opval); }
 808
 809     break;
 810
 811   case 109:
 812 #line 701 "perly.y"
 813     { (yyval.ival) = '@'; }
 814
 815     break;
 816
 817   case 110:
 818 #line 703 "perly.y"
 819     { (yyval.ival) = '%'; }
 820
 821     break;
 822
 823   case 111:
 824 #line 707 "perly.y"
 825     {
 826                             I32 sigil   = (ps[-2].val.ival);
 827                             OP *var     = (ps[-1].val.opval);
 828                             OP *defexpr = (ps[0].val.opval);
 829
 830                             if (parser->sig_slurpy)
 831                                 yyerror("Multiple slurpy parameters not allowed");
 832                             parser->sig_slurpy = (char)sigil;
 833
 834                             if (defexpr)
 835                                 yyerror("A slurpy parameter may not have "
 836                                         "a default value");
 837
 838                             (yyval.opval) = var ? newSTATEOP(0, NULL, var) : NULL;
 839                         }
 840
 841     break;
 842
 843   case 113:
 844 #line 728 "perly.y"
 845     { (yyval.opval) = newOP(OP_NULL, 0); }
 846
 847     break;
 848
 849   case 114:
 850 #line 730 "perly.y"
 851     { (yyval.opval) = (ps[0].val.opval); }
 852
 853     break;
 854
 855   case 115:
 856 #line 736 "perly.y"
 857     {
 858                             OP *var     = (ps[-1].val.opval);
 859                             OP *defexpr = (ps[0].val.opval);
 860
 861                             if (parser->sig_slurpy)
 862                                 yyerror("Slurpy parameter not last");
 863
 864                             parser->sig_elems++;
 865
 866                             if (defexpr) {
 867                                 parser->sig_optelems++;
 868
 869                                 if (   defexpr->op_type == OP_NULL
 870                                     && !(defexpr->op_flags & OPf_KIDS))
 871                                 {
 872                                     /* handle '$=' special case */
 873                                     if (var)
 874                                         yyerror("Optional parameter "
 875                                                     "lacks default expression");
 876                                     op_free(defexpr);
 877                                 }
 878                                 else {
 879                                     /* a normal '=default' expression */
 880                                     OP *defop = (OP*)alloc_LOGOP(OP_ARGDEFELEM,
 881                                                         defexpr,
 882                                                         LINKLIST(defexpr));
 883                                     /* re-purpose op_targ to hold @_ index */
 884                                     defop->op_targ =
 885                                         (PADOFFSET)(parser->sig_elems - 1);
 886
 887                                     if (var) {
 888                                         var->op_flags |= OPf_STACKED;
 889                                         (void)op_sibling_splice(var,
 890                                                         NULL, 0, defop);
 891                                         scalar(defop);
 892                                     }
 893                                     else
 894                                         var = newUNOP(OP_NULL, 0, defop);
 895
 896                                     LINKLIST(var);
 897                                     /* NB: normally the first child of a
 898                                      * logop is executed before the logop,
 899                                      * and it pushes a boolean result
 900                                      * ready for the logop. For ARGDEFELEM,
 901                                      * the op itself does the boolean
 902                                      * calculation, so set the first op to
 903                                      * it instead.
 904                                      */
 905                                     var->op_next = defop;
 906                                     defexpr->op_next = var;
 907                                 }
 908                             }
 909                             else {
 910                                 if (parser->sig_optelems)
 911                                     yyerror("Mandatory parameter "
 912                                             "follows optional parameter");
 913                             }
 914
 915                             (yyval.opval) = var ? newSTATEOP(0, NULL, var) : NULL;
 916                         }
 917
 918     break;
 919
 920   case 116:
 921 #line 801 "perly.y"
 922     { parser->in_my = KEY_sigvar; (yyval.opval) = (ps[0].val.opval); }
 923
 924     break;
 925
 926   case 117:
 927 #line 803 "perly.y"
 928     { parser->in_my = KEY_sigvar; (yyval.opval) = (ps[0].val.opval); }
 929
 930     break;
 931
 932   case 118:
 933 #line 809 "perly.y"
 934     { (yyval.opval) = (ps[-1].val.opval); }
 935
 936     break;
 937
 938   case 119:
 939 #line 811 "perly.y"
 940     {
 941                           (yyval.opval) = op_append_list(OP_LINESEQ, (ps[-2].val.opval), (ps[0].val.opval));
 942                         }
 943
 944     break;
 945
 946   case 120:
 947 #line 815 "perly.y"
 948     { (yyval.opval) = (ps[0].val.opval); }
 949
 950     break;
 951
 952   case 125:
 953 #line 832 "perly.y"
 954     { (yyval.opval) = (ps[-1].val.opval); }
 955
 956     break;
 957
 958   case 126:
 959 #line 835 "perly.y"
 960     {
 961                             ENTER;
 962                             SAVEIV(parser->sig_elems);
 963                             SAVEIV(parser->sig_optelems);
 964                             SAVEI8(parser->sig_slurpy);
 965                             parser->sig_elems    = 0;
 966                             parser->sig_optelems = 0;
 967                             parser->sig_slurpy   = 0;
 968                             parser->in_my        = KEY_sigvar;
 969                         }
 970
 971     break;
 972
 973   case 127:
 974 #line 846 "perly.y"
 975     {
 976                             OP            *sigops = (ps[0].val.opval);
 977                             struct op_argcheck_aux *aux;
 978                             OP            *check;
 979
 980                             if (!FEATURE_SIGNATURES_IS_ENABLED)
 981                                 Perl_croak(aTHX_ "Experimental "
 982                                     "subroutine signatures not enabled");
 983
 984                             /* We shouldn't get here otherwise */
 985                             Perl_ck_warner_d(aTHX_
 986                                 packWARN(WARN_EXPERIMENTAL__SIGNATURES),
 987                                 "The signatures feature is experimental");
 988
 989                             aux = (struct op_argcheck_aux*)
 990                                     PerlMemShared_malloc(
 991                                         sizeof(struct op_argcheck_aux));
 992                             aux->params     = parser->sig_elems;
 993                             aux->opt_params = parser->sig_optelems;
 994                             aux->slurpy     = parser->sig_slurpy;
 995                             check = newUNOP_AUX(OP_ARGCHECK, 0, NULL,
 996                                             (UNOP_AUX_item *)aux);
 997                             sigops = op_prepend_elem(OP_LINESEQ, check, sigops);
 998                             sigops = op_prepend_elem(OP_LINESEQ,
 999                                                 newSTATEOP(0, NULL, NULL),
1000                                                 sigops);
1001                             /* a nextstate at the end handles context
1002                              * correctly for an empty sub body */
1003                             sigops = op_append_elem(OP_LINESEQ,
1004                                                 sigops,
1005                                                 newSTATEOP(0, NULL, NULL));
1006                             /* wrap the list of arg ops in a NULL aux op.
1007                               This serves two purposes. First, it makes
1008                               the arg list a separate subtree from the
1009                               body of the sub, and secondly the null op
1010                               may in future be upgraded to an OP_SIGNATURE
1011                               when implemented. For now leave it as
1012                               ex-argcheck */
1013                             (yyval.opval) = newUNOP_AUX(OP_ARGCHECK, 0, sigops, NULL);
1014                             op_null((yyval.opval));
1015
1016                             CvSIGNATURE_on(PL_compcv);
1017
1018                             parser->in_my = 0;
1019                             /* tell the toker that attrributes can follow
1020                              * this sig, but only so that the toker
1021                              * can skip through any (illegal) trailing
1022                              * attribute text then give a useful error
1023                              * message about "attributes before sig",
1024                              * rather than falling over ina mess at
1025                              * unrecognised syntax.
1026                              */
1027                             parser->expect = XATTRBLOCK;
1028                             parser->sig_seen = TRUE;
1029                             LEAVE;
1030                         }
1031
1032     break;
1033
1034   case 129:
1035 #line 907 "perly.y"
1036     { (yyval.opval) = NULL; }
1037
1038     break;
1039
1040   case 130:
1041 #line 913 "perly.y"
1042     {
1043                           if (parser->copline > (line_t)(ps[-2].val.ival))
1044                               parser->copline = (line_t)(ps[-2].val.ival);
1045                           (yyval.opval) = block_end((ps[-3].val.ival), (ps[-1].val.opval));
1046                         }
1047
1048     break;
1049
1050   case 132:
1051 #line 925 "perly.y"
1052     { (yyval.opval) = NULL; }
1053
1054     break;
1055
1056   case 133:
1057 #line 930 "perly.y"
1058     {
1059                           if (parser->copline > (line_t)(ps[-2].val.ival))
1060                               parser->copline = (line_t)(ps[-2].val.ival);
1061                           (yyval.opval) = block_end((ps[-4].val.ival),
1062                                 op_append_list(OP_LINESEQ, (ps[-3].val.opval), (ps[-1].val.opval)));
1063                         }
1064
1065     break;
1066
1067   case 134:
1068 #line 941 "perly.y"
1069     { (yyval.opval) = newLOGOP(OP_AND, 0, (ps[-2].val.opval), (ps[0].val.opval)); }
1070
1071     break;
1072
1073   case 135:
1074 #line 943 "perly.y"
1075     { (yyval.opval) = newLOGOP((ps[-1].val.ival), 0, (ps[-2].val.opval), (ps[0].val.opval)); }
1076
1077     break;
1078
1079   case 137:
1080 #line 949 "perly.y"
1081     { (yyval.opval) = (ps[-1].val.opval); }
1082
1083     break;
1084
1085   case 138:
1086 #line 951 "perly.y"
1087     {
1088                           OP* term = (ps[0].val.opval);
1089                           (yyval.opval) = op_append_elem(OP_LIST, (ps[-2].val.opval), term);
1090                         }
1091
1092     break;
1093
1094   case 140:
1095 #line 960 "perly.y"
1096     { (yyval.opval) = op_convert_list((ps[-2].val.ival), OPf_STACKED,
1097                                 op_prepend_elem(OP_LIST, newGVREF((ps[-2].val.ival),(ps[-1].val.opval)), (ps[0].val.opval)) );
1098                         }
1099
1100     break;
1101
1102   case 141:
1103 #line 964 "perly.y"
1104     { (yyval.opval) = op_convert_list((ps[-4].val.ival), OPf_STACKED,
1105                                 op_prepend_elem(OP_LIST, newGVREF((ps[-4].val.ival),(ps[-2].val.opval)), (ps[-1].val.opval)) );
1106                         }
1107
1108     break;
1109
1110   case 142:
1111 #line 968 "perly.y"
1112     { (yyval.opval) = op_convert_list(OP_ENTERSUB, OPf_STACKED,
1113                                 op_append_elem(OP_LIST,
1114                                     op_prepend_elem(OP_LIST, scalar((ps[-5].val.opval)), (ps[-1].val.opval)),
1115                                     newMETHOP(OP_METHOD, 0, (ps[-3].val.opval))));
1116                         }
1117
1118     break;
1119
1120   case 143:
1121 #line 974 "perly.y"
1122     { (yyval.opval) = op_convert_list(OP_ENTERSUB, OPf_STACKED,
1123                                 op_append_elem(OP_LIST, scalar((ps[-2].val.opval)),
1124                                     newMETHOP(OP_METHOD, 0, (ps[0].val.opval))));
1125                         }
1126
1127     break;
1128
1129   case 144:
1130 #line 979 "perly.y"
1131     { (yyval.opval) = op_convert_list(OP_ENTERSUB, OPf_STACKED,
1132                                 op_append_elem(OP_LIST,
1133                                     op_prepend_elem(OP_LIST, (ps[-1].val.opval), (ps[0].val.opval)),
1134                                     newMETHOP(OP_METHOD, 0, (ps[-2].val.opval))));
1135                         }
1136
1137     break;
1138
1139   case 145:
1140 #line 985 "perly.y"
1141     { (yyval.opval) = op_convert_list(OP_ENTERSUB, OPf_STACKED,
1142                                 op_append_elem(OP_LIST,
1143                                     op_prepend_elem(OP_LIST, (ps[-3].val.opval), (ps[-1].val.opval)),
1144                                     newMETHOP(OP_METHOD, 0, (ps[-4].val.opval))));
1145                         }
1146
1147     break;
1148
1149   case 146:
1150 #line 991 "perly.y"
1151     { (yyval.opval) = op_convert_list((ps[-1].val.ival), 0, (ps[0].val.opval)); }
1152
1153     break;
1154
1155   case 147:
1156 #line 993 "perly.y"
1157     { (yyval.opval) = op_convert_list((ps[-3].val.ival), 0, (ps[-1].val.opval)); }
1158
1159     break;
1160
1161   case 148:
1162 #line 995 "perly.y"
1163     { (yyval.opval) = op_convert_list((ps[-3].val.ival), 0, (ps[-1].val.opval)); }
1164
1165     break;
1166
1167   case 149:
1168 #line 997 "perly.y"
1169     { SvREFCNT_inc_simple_void(PL_compcv);
1170                           (yyval.opval) = newANONATTRSUB((ps[-1].val.ival), 0, NULL, (ps[0].val.opval)); }
1171
1172     break;
1173
1174   case 150:
1175 #line 1000 "perly.y"
1176     { (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED,
1177                                  op_append_elem(OP_LIST,
1178                                    op_prepend_elem(OP_LIST, (ps[-1].val.opval), (ps[0].val.opval)), (ps[-4].val.opval)));
1179                         }
1180
1181     break;
1182
1183   case 153:
1184 #line 1015 "perly.y"
1185     { (yyval.opval) = newBINOP(OP_GELEM, 0, (ps[-4].val.opval), scalar((ps[-2].val.opval))); }
1186
1187     break;
1188
1189   case 154:
1190 #line 1017 "perly.y"
1191     { (yyval.opval) = newBINOP(OP_AELEM, 0, oopsAV((ps[-3].val.opval)), scalar((ps[-1].val.opval)));
1192                         }
1193
1194     break;
1195
1196   case 155:
1197 #line 1020 "perly.y"
1198     { (yyval.opval) = newBINOP(OP_AELEM, 0,
1199                                         ref(newAVREF((ps[-4].val.opval)),OP_RV2AV),
1200                                         scalar((ps[-1].val.opval)));
1201                         }
1202
1203     break;
1204
1205   case 156:
1206 #line 1025 "perly.y"
1207     { (yyval.opval) = newBINOP(OP_AELEM, 0,
1208                                         ref(newAVREF((ps[-3].val.opval)),OP_RV2AV),
1209                                         scalar((ps[-1].val.opval)));
1210                         }
1211
1212     break;
1213
1214   case 157:
1215 #line 1030 "perly.y"
1216     { (yyval.opval) = newBINOP(OP_HELEM, 0, oopsHV((ps[-4].val.opval)), jmaybe((ps[-2].val.opval)));
1217                         }
1218
1219     break;
1220
1221   case 158:
1222 #line 1033 "perly.y"
1223     { (yyval.opval) = newBINOP(OP_HELEM, 0,
1224                                         ref(newHVREF((ps[-5].val.opval)),OP_RV2HV),
1225                                         jmaybe((ps[-2].val.opval))); }
1226
1227     break;
1228
1229   case 159:
1230 #line 1037 "perly.y"
1231     { (yyval.opval) = newBINOP(OP_HELEM, 0,
1232                                         ref(newHVREF((ps[-4].val.opval)),OP_RV2HV),
1233                                         jmaybe((ps[-2].val.opval))); }
1234
1235     break;
1236
1237   case 160:
1238 #line 1041 "perly.y"
1239     { (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED,
1240                                    newCVREF(0, scalar((ps[-3].val.opval))));
1241                           if (parser->expect == XBLOCK)
1242                               parser->expect = XOPERATOR;
1243                         }
1244
1245     break;
1246
1247   case 161:
1248 #line 1047 "perly.y"
1249     { (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED,
1250                                    op_append_elem(OP_LIST, (ps[-1].val.opval),
1251                                        newCVREF(0, scalar((ps[-4].val.opval)))));
1252                           if (parser->expect == XBLOCK)
1253                               parser->expect = XOPERATOR;
1254                         }
1255
1256     break;
1257
1258   case 162:
1259 #line 1055 "perly.y"
1260     { (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED,
1261                                    op_append_elem(OP_LIST, (ps[-1].val.opval),
1262                                                newCVREF(0, scalar((ps[-3].val.opval)))));
1263                           if (parser->expect == XBLOCK)
1264                               parser->expect = XOPERATOR;
1265                         }
1266
1267     break;
1268
1269   case 163:
1270 #line 1062 "perly.y"
1271     { (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED,
1272                                    newCVREF(0, scalar((ps[-2].val.opval))));
1273                           if (parser->expect == XBLOCK)
1274                               parser->expect = XOPERATOR;
1275                         }
1276
1277     break;
1278
1279   case 164:
1280 #line 1068 "perly.y"
1281     { (yyval.opval) = newSLICEOP(0, (ps[-1].val.opval), (ps[-4].val.opval)); }
1282
1283     break;
1284
1285   case 165:
1286 #line 1070 "perly.y"
1287     { (yyval.opval) = newSLICEOP(0, (ps[-1].val.opval), (ps[-3].val.opval)); }
1288
1289     break;
1290
1291   case 166:
1292 #line 1072 "perly.y"
1293     { (yyval.opval) = newSLICEOP(0, (ps[-1].val.opval), NULL); }
1294
1295     break;
1296
1297   case 167:
1298 #line 1077 "perly.y"
1299     { (yyval.opval) = newASSIGNOP(OPf_STACKED, (ps[-2].val.opval), (ps[-1].val.ival), (ps[0].val.opval)); }
1300
1301     break;
1302
1303   case 168:
1304 #line 1079 "perly.y"
1305     { (yyval.opval) = newBINOP((ps[-1].val.ival), 0, scalar((ps[-2].val.opval)), scalar((ps[0].val.opval))); }
1306
1307     break;
1308
1309   case 169:
1310 #line 1081 "perly.y"
1311     {   if ((ps[-1].val.ival) != OP_REPEAT)
1312                                 scalar((ps[-2].val.opval));
1313                             (yyval.opval) = newBINOP((ps[-1].val.ival), 0, (ps[-2].val.opval), scalar((ps[0].val.opval)));
1314                         }
1315
1316     break;
1317
1318   case 170:
1319 #line 1086 "perly.y"
1320     { (yyval.opval) = newBINOP((ps[-1].val.ival), 0, scalar((ps[-2].val.opval)), scalar((ps[0].val.opval))); }
1321
1322     break;
1323
1324   case 171:
1325 #line 1088 "perly.y"
1326     { (yyval.opval) = newBINOP((ps[-1].val.ival), 0, scalar((ps[-2].val.opval)), scalar((ps[0].val.opval))); }
1327
1328     break;
1329
1330   case 172:
1331 #line 1090 "perly.y"
1332     { (yyval.opval) = (ps[0].val.opval); }
1333
1334     break;
1335
1336   case 173:
1337 #line 1092 "perly.y"
1338     { (yyval.opval) = (ps[0].val.opval); }
1339
1340     break;
1341
1342   case 174:
1343 #line 1094 "perly.y"
1344     { (yyval.opval) = newBINOP((ps[-1].val.ival), 0, scalar((ps[-2].val.opval)), scalar((ps[0].val.opval))); }
1345
1346     break;
1347
1348   case 175:
1349 #line 1096 "perly.y"
1350     { (yyval.opval) = newBINOP((ps[-1].val.ival), 0, scalar((ps[-2].val.opval)), scalar((ps[0].val.opval))); }
1351
1352     break;
1353
1354   case 176:
1355 #line 1098 "perly.y"
1356     { (yyval.opval) = newRANGE((ps[-1].val.ival), scalar((ps[-2].val.opval)), scalar((ps[0].val.opval))); }
1357
1358     break;
1359
1360   case 177:
1361 #line 1100 "perly.y"
1362     { (yyval.opval) = newLOGOP(OP_AND, 0, (ps[-2].val.opval), (ps[0].val.opval)); }
1363
1364     break;
1365
1366   case 178:
1367 #line 1102 "perly.y"
1368     { (yyval.opval) = newLOGOP(OP_OR, 0, (ps[-2].val.opval), (ps[0].val.opval)); }
1369
1370     break;
1371
1372   case 179:
1373 #line 1104 "perly.y"
1374     { (yyval.opval) = newLOGOP(OP_DOR, 0, (ps[-2].val.opval), (ps[0].val.opval)); }
1375
1376     break;
1377
1378   case 180:
1379 #line 1106 "perly.y"
1380     { (yyval.opval) = bind_match((ps[-1].val.ival), (ps[-2].val.opval), (ps[0].val.opval)); }
1381
1382     break;
1383
1384   case 181:
1385 #line 1110 "perly.y"
1386     { (yyval.opval) = cmpchain_finish((ps[0].val.opval)); }
1387
1388     break;
1389
1390   case 182:
1391 #line 1112 "perly.y"
1392     { (yyval.opval) = newBINOP((ps[-1].val.ival), 0, scalar((ps[-2].val.opval)), scalar((ps[0].val.opval))); }
1393
1394     break;
1395
1396   case 183:
1397 #line 1114 "perly.y"
1398     { yyerror("syntax error"); YYERROR; }
1399
1400     break;
1401
1402   case 184:
1403 #line 1116 "perly.y"
1404     { yyerror("syntax error"); YYERROR; }
1405
1406     break;
1407
1408   case 185:
1409 #line 1120 "perly.y"
1410     { (yyval.opval) = cmpchain_start((ps[-1].val.ival), (ps[-2].val.opval), (ps[0].val.opval)); }
1411
1412     break;
1413
1414   case 186:
1415 #line 1122 "perly.y"
1416     { (yyval.opval) = cmpchain_extend((ps[-1].val.ival), (ps[-2].val.opval), (ps[0].val.opval)); }
1417
1418     break;
1419
1420   case 187:
1421 #line 1126 "perly.y"
1422     { (yyval.opval) = cmpchain_finish((ps[0].val.opval)); }
1423
1424     break;
1425
1426   case 188:
1427 #line 1128 "perly.y"
1428     { (yyval.opval) = newBINOP((ps[-1].val.ival), 0, scalar((ps[-2].val.opval)), scalar((ps[0].val.opval))); }
1429
1430     break;
1431
1432   case 189:
1433 #line 1130 "perly.y"
1434     { yyerror("syntax error"); YYERROR; }
1435
1436     break;
1437
1438   case 190:
1439 #line 1132 "perly.y"
1440     { yyerror("syntax error"); YYERROR; }
1441
1442     break;
1443
1444   case 191:
1445 #line 1136 "perly.y"
1446     { (yyval.opval) = cmpchain_start((ps[-1].val.ival), (ps[-2].val.opval), (ps[0].val.opval)); }
1447
1448     break;
1449
1450   case 192:
1451 #line 1138 "perly.y"
1452     { (yyval.opval) = cmpchain_extend((ps[-1].val.ival), (ps[-2].val.opval), (ps[0].val.opval)); }
1453
1454     break;
1455
1456   case 193:
1457 #line 1143 "perly.y"
1458     { (yyval.opval) = newUNOP(OP_NEGATE, 0, scalar((ps[0].val.opval))); }
1459
1460     break;
1461
1462   case 194:
1463 #line 1145 "perly.y"
1464     { (yyval.opval) = (ps[0].val.opval); }
1465
1466     break;
1467
1468   case 195:
1469 #line 1148 "perly.y"
1470     { (yyval.opval) = newUNOP(OP_NOT, 0, scalar((ps[0].val.opval))); }
1471
1472     break;
1473
1474   case 196:
1475 #line 1150 "perly.y"
1476     { (yyval.opval) = newUNOP((ps[-1].val.ival), 0, scalar((ps[0].val.opval))); }
1477
1478     break;
1479
1480   case 197:
1481 #line 1152 "perly.y"
1482     { (yyval.opval) = newUNOP(OP_POSTINC, 0,
1483                                         op_lvalue(scalar((ps[-1].val.opval)), OP_POSTINC)); }
1484
1485     break;
1486
1487   case 198:
1488 #line 1155 "perly.y"
1489     { (yyval.opval) = newUNOP(OP_POSTDEC, 0,
1490                                         op_lvalue(scalar((ps[-1].val.opval)), OP_POSTDEC));}
1491
1492     break;
1493
1494   case 199:
1495 #line 1158 "perly.y"
1496     { (yyval.opval) = op_convert_list(OP_JOIN, 0,
1497                                        op_append_elem(
1498                                         OP_LIST,
1499                                         newSVREF(scalar(
1500                                             newSVOP(OP_CONST,0,
1501                                                     newSVpvs("\""))
1502                                         )),
1503                                         (ps[-1].val.opval)
1504                                        ));
1505                         }
1506
1507     break;
1508
1509   case 200:
1510 #line 1169 "perly.y"
1511     { (yyval.opval) = newUNOP(OP_PREINC, 0,
1512                                         op_lvalue(scalar((ps[0].val.opval)), OP_PREINC)); }
1513
1514     break;
1515
1516   case 201:
1517 #line 1172 "perly.y"
1518     { (yyval.opval) = newUNOP(OP_PREDEC, 0,
1519                                         op_lvalue(scalar((ps[0].val.opval)), OP_PREDEC)); }
1520
1521     break;
1522
1523   case 202:
1524 #line 1179 "perly.y"
1525     { (yyval.opval) = newANONLIST((ps[-1].val.opval)); }
1526
1527     break;
1528
1529   case 203:
1530 #line 1181 "perly.y"
1531     { (yyval.opval) = newANONLIST(NULL);}
1532
1533     break;
1534
1535   case 204:
1536 #line 1183 "perly.y"
1537     { (yyval.opval) = newANONHASH((ps[-2].val.opval)); }
1538
1539     break;
1540
1541   case 205:
1542 #line 1185 "perly.y"
1543     { (yyval.opval) = newANONHASH(NULL); }
1544
1545     break;
1546
1547   case 206:
1548 #line 1187 "perly.y"
1549     { SvREFCNT_inc_simple_void(PL_compcv);
1550                           (yyval.opval) = newANONATTRSUB((ps[-3].val.ival), (ps[-2].val.opval), (ps[-1].val.opval), (ps[0].val.opval)); }
1551
1552     break;
1553
1554   case 207:
1555 #line 1190 "perly.y"
1556     { SvREFCNT_inc_simple_void(PL_compcv);
1557                           (yyval.opval) = newANONATTRSUB((ps[-2].val.ival), NULL, (ps[-1].val.opval), (ps[0].val.opval)); }
1558
1559     break;
1560
1561   case 208:
1562 #line 1196 "perly.y"
1563     { (yyval.opval) = dofile((ps[0].val.opval), (ps[-1].val.ival));}
1564
1565     break;
1566
1567   case 209:
1568 #line 1198 "perly.y"
1569     { (yyval.opval) = newUNOP(OP_NULL, OPf_SPECIAL, op_scope((ps[0].val.opval)));}
1570
1571     break;
1572
1573   case 214:
1574 #line 1206 "perly.y"
1575     { (yyval.opval) = newCONDOP(0, (ps[-4].val.opval), (ps[-2].val.opval), (ps[0].val.opval)); }
1576
1577     break;
1578
1579   case 215:
1580 #line 1208 "perly.y"
1581     { (yyval.opval) = newUNOP(OP_REFGEN, 0, (ps[0].val.opval)); }
1582
1583     break;
1584
1585   case 216:
1586 #line 1210 "perly.y"
1587     { (yyval.opval) = (ps[0].val.opval); }
1588
1589     break;
1590
1591   case 217:
1592 #line 1212 "perly.y"
1593     { (yyval.opval) = localize((ps[0].val.opval),0); }
1594
1595     break;
1596
1597   case 218:
1598 #line 1214 "perly.y"
1599     { (yyval.opval) = sawparens((ps[-1].val.opval)); }
1600
1601     break;
1602
1603   case 219:
1604 #line 1216 "perly.y"
1605     { (yyval.opval) = (ps[0].val.opval); }
1606
1607     break;
1608
1609   case 220:
1610 #line 1218 "perly.y"
1611     { (yyval.opval) = sawparens(newNULLLIST()); }
1612
1613     break;
1614
1615   case 221:
1616 #line 1220 "perly.y"
1617     { (yyval.opval) = (ps[0].val.opval); }
1618
1619     break;
1620
1621   case 222:
1622 #line 1222 "perly.y"
1623     { (yyval.opval) = (ps[0].val.opval); }
1624
1625     break;
1626
1627   case 223:
1628 #line 1224 "perly.y"
1629     { (yyval.opval) = (ps[0].val.opval); }
1630
1631     break;
1632
1633   case 224:
1634 #line 1226 "perly.y"
1635     { (yyval.opval) = (ps[0].val.opval); }
1636
1637     break;
1638
1639   case 225:
1640 #line 1228 "perly.y"
1641     { (yyval.opval) = newUNOP(OP_AV2ARYLEN, 0, ref((ps[0].val.opval), OP_AV2ARYLEN));}
1642
1643     break;
1644
1645   case 226:
1646 #line 1230 "perly.y"
1647     { (yyval.opval) = (ps[0].val.opval); }
1648
1649     break;
1650
1651   case 227:
1652 #line 1232 "perly.y"
1653     { (yyval.opval) = op_prepend_elem(OP_ASLICE,
1654                                 newOP(OP_PUSHMARK, 0),
1655                                     newLISTOP(OP_ASLICE, 0,
1656                                         list((ps[-1].val.opval)),
1657                                         ref((ps[-3].val.opval), OP_ASLICE)));
1658                           if ((yyval.opval) && (ps[-3].val.opval))
1659                               (yyval.opval)->op_private |=
1660                                   (ps[-3].val.opval)->op_private & OPpSLICEWARNING;
1661                         }
1662
1663     break;
1664
1665   case 228:
1666 #line 1242 "perly.y"
1667     { (yyval.opval) = op_prepend_elem(OP_KVASLICE,
1668                                 newOP(OP_PUSHMARK, 0),
1669                                     newLISTOP(OP_KVASLICE, 0,
1670                                         list((ps[-1].val.opval)),
1671                                         ref(oopsAV((ps[-3].val.opval)), OP_KVASLICE)));
1672                           if ((yyval.opval) && (ps[-3].val.opval))
1673                               (yyval.opval)->op_private |=
1674                                   (ps[-3].val.opval)->op_private & OPpSLICEWARNING;
1675                         }
1676
1677     break;
1678
1679   case 229:
1680 #line 1252 "perly.y"
1681     { (yyval.opval) = op_prepend_elem(OP_HSLICE,
1682                                 newOP(OP_PUSHMARK, 0),
1683                                     newLISTOP(OP_HSLICE, 0,
1684                                         list((ps[-2].val.opval)),
1685                                         ref(oopsHV((ps[-4].val.opval)), OP_HSLICE)));
1686                           if ((yyval.opval) && (ps[-4].val.opval))
1687                               (yyval.opval)->op_private |=
1688                                   (ps[-4].val.opval)->op_private & OPpSLICEWARNING;
1689                         }
1690
1691     break;
1692
1693   case 230:
1694 #line 1262 "perly.y"
1695     { (yyval.opval) = op_prepend_elem(OP_KVHSLICE,
1696                                 newOP(OP_PUSHMARK, 0),
1697                                     newLISTOP(OP_KVHSLICE, 0,
1698                                         list((ps[-2].val.opval)),
1699                                         ref((ps[-4].val.opval), OP_KVHSLICE)));
1700                           if ((yyval.opval) && (ps[-4].val.opval))
1701                               (yyval.opval)->op_private |=
1702                                   (ps[-4].val.opval)->op_private & OPpSLICEWARNING;
1703                         }
1704
1705     break;
1706
1707   case 231:
1708 #line 1272 "perly.y"
1709     { (yyval.opval) = (ps[0].val.opval); }
1710
1711     break;
1712
1713   case 232:
1714 #line 1274 "perly.y"
1715     { (yyval.opval) = newUNOP(OP_ENTERSUB, 0, scalar((ps[0].val.opval))); }
1716
1717     break;
1718
1719   case 233:
1720 #line 1276 "perly.y"
1721     { (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED, scalar((ps[-2].val.opval)));
1722                         }
1723
1724     break;
1725
1726   case 234:
1727 #line 1279 "perly.y"
1728     {
1729                           (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED,
1730                                 op_append_elem(OP_LIST, (ps[-1].val.opval), scalar((ps[-3].val.opval))));
1731                         }
1732
1733     break;
1734
1735   case 235:
1736 #line 1284 "perly.y"
1737     { (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED,
1738                             op_append_elem(OP_LIST, (ps[0].val.opval), scalar((ps[-1].val.opval))));
1739                         }
1740
1741     break;
1742
1743   case 236:
1744 #line 1288 "perly.y"
1745     { (yyval.opval) = newSVREF((ps[-3].val.opval)); }
1746
1747     break;
1748
1749   case 237:
1750 #line 1290 "perly.y"
1751     { (yyval.opval) = newAVREF((ps[-3].val.opval)); }
1752
1753     break;
1754
1755   case 238:
1756 #line 1292 "perly.y"
1757     { (yyval.opval) = newHVREF((ps[-3].val.opval)); }
1758
1759     break;
1760
1761   case 239:
1762 #line 1294 "perly.y"
1763     { (yyval.opval) = newUNOP(OP_ENTERSUB, 0,
1764                                        scalar(newCVREF((ps[-1].val.ival),(ps[-3].val.opval)))); }
1765
1766     break;
1767
1768   case 240:
1769 #line 1297 "perly.y"
1770     { (yyval.opval) = newGVREF(0,(ps[-3].val.opval)); }
1771
1772     break;
1773
1774   case 241:
1775 #line 1299 "perly.y"
1776     { (yyval.opval) = newOP((ps[0].val.ival), OPf_SPECIAL);
1777                             PL_hints |= HINT_BLOCK_SCOPE; }
1778
1779     break;
1780
1781   case 242:
1782 #line 1302 "perly.y"
1783     { (yyval.opval) = newLOOPEX((ps[-1].val.ival),(ps[0].val.opval)); }
1784
1785     break;
1786
1787   case 243:
1788 #line 1304 "perly.y"
1789     { (yyval.opval) = newUNOP(OP_NOT, 0, scalar((ps[0].val.opval))); }
1790
1791     break;
1792
1793   case 244:
1794 #line 1306 "perly.y"
1795     { (yyval.opval) = newOP((ps[0].val.ival), 0); }
1796
1797     break;
1798
1799   case 245:
1800 #line 1308 "perly.y"
1801     { (yyval.opval) = newUNOP((ps[-1].val.ival), 0, (ps[0].val.opval)); }
1802
1803     break;
1804
1805   case 246:
1806 #line 1310 "perly.y"
1807     { (yyval.opval) = newUNOP((ps[-1].val.ival), 0, (ps[0].val.opval)); }
1808
1809     break;
1810
1811   case 247:
1812 #line 1312 "perly.y"
1813     { (yyval.opval) = newOP(OP_REQUIRE, (ps[0].val.ival) ? OPf_SPECIAL : 0); }
1814
1815     break;
1816
1817   case 248:
1818 #line 1314 "perly.y"
1819     { (yyval.opval) = newUNOP(OP_REQUIRE, (ps[-1].val.ival) ? OPf_SPECIAL : 0, (ps[0].val.opval)); }
1820
1821     break;
1822
1823   case 249:
1824 #line 1316 "perly.y"
1825     { (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED, scalar((ps[0].val.opval))); }
1826
1827     break;
1828
1829   case 250:
1830 #line 1318 "perly.y"
1831     { (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED,
1832                             op_append_elem(OP_LIST, (ps[0].val.opval), scalar((ps[-1].val.opval)))); }
1833
1834     break;
1835
1836   case 251:
1837 #line 1321 "perly.y"
1838     { (yyval.opval) = newOP((ps[0].val.ival), 0); }
1839
1840     break;
1841
1842   case 252:
1843 #line 1323 "perly.y"
1844     { (yyval.opval) = newOP((ps[-2].val.ival), 0);}
1845
1846     break;
1847
1848   case 253:
1849 #line 1325 "perly.y"
1850     { (yyval.opval) = (ps[0].val.opval); }
1851
1852     break;
1853
1854   case 254:
1855 #line 1327 "perly.y"
1856     { (yyval.opval) = (ps[-2].val.opval); }
1857
1858     break;
1859
1860   case 255:
1861 #line 1329 "perly.y"
1862     { (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED, scalar((ps[0].val.opval))); }
1863
1864     break;
1865
1866   case 256:
1867 #line 1331 "perly.y"
1868     { (yyval.opval) = ((ps[-2].val.ival) == OP_NOT)
1869                           ? newUNOP((ps[-2].val.ival), 0, newSVOP(OP_CONST, 0, newSViv(0)))
1870                           : newOP((ps[-2].val.ival), OPf_SPECIAL); }
1871
1872     break;
1873
1874   case 257:
1875 #line 1335 "perly.y"
1876     { (yyval.opval) = newUNOP((ps[-3].val.ival), 0, (ps[-1].val.opval)); }
1877
1878     break;
1879
1880   case 258:
1881 #line 1337 "perly.y"
1882     {
1883                             if (   (ps[0].val.opval)->op_type != OP_TRANS
1884                                 && (ps[0].val.opval)->op_type != OP_TRANSR
1885                                 && (((PMOP*)(ps[0].val.opval))->op_pmflags & PMf_HAS_CV))
1886                             {
1887                                 (yyval.ival) = start_subparse(FALSE, CVf_ANON);
1888                                 SAVEFREESV(PL_compcv);
1889                             } else
1890                                 (yyval.ival) = 0;
1891                         }
1892
1893     break;
1894
1895   case 259:
1896 #line 1348 "perly.y"
1897     { (yyval.opval) = pmruntime((ps[-5].val.opval), (ps[-2].val.opval), (ps[-1].val.opval), 1, (ps[-4].val.ival)); }
1898
1899     break;
1900
1901   case 263:
1902 #line 1357 "perly.y"
1903     { (yyval.opval) = my_attrs((ps[-1].val.opval),(ps[0].val.opval)); }
1904
1905     break;
1906
1907   case 264:
1908 #line 1359 "perly.y"
1909     { (yyval.opval) = localize((ps[0].val.opval),1); }
1910
1911     break;
1912
1913   case 265:
1914 #line 1361 "perly.y"
1915     { (yyval.opval) = newUNOP(OP_REFGEN, 0, my_attrs((ps[-1].val.opval),(ps[0].val.opval))); }
1916
1917     break;
1918
1919   case 266:
1920 #line 1363 "perly.y"
1921     { (yyval.opval) = newUNOP(OP_REFGEN, 0, localize((ps[0].val.opval),1)); }
1922
1923     break;
1924
1925   case 267:
1926 #line 1368 "perly.y"
1927     { (yyval.opval) = sawparens((ps[-1].val.opval)); }
1928
1929     break;
1930
1931   case 268:
1932 #line 1370 "perly.y"
1933     { (yyval.opval) = sawparens(newNULLLIST()); }
1934
1935     break;
1936
1937   case 269:
1938 #line 1373 "perly.y"
1939     { (yyval.opval) = (ps[0].val.opval); }
1940
1941     break;
1942
1943   case 270:
1944 #line 1375 "perly.y"
1945     { (yyval.opval) = (ps[0].val.opval); }
1946
1947     break;
1948
1949   case 271:
1950 #line 1377 "perly.y"
1951     { (yyval.opval) = (ps[0].val.opval); }
1952
1953     break;
1954
1955   case 277:
1956 #line 1393 "perly.y"
1957     { (yyval.opval) = (ps[0].val.opval); }
1958
1959     break;
1960
1961   case 278:
1962 #line 1399 "perly.y"
1963     { parser->in_my = 0; (yyval.opval) = my((ps[0].val.opval)); }
1964
1965     break;
1966
1967   case 279:
1968 #line 1404 "perly.y"
1969     { (yyval.opval) = (ps[-1].val.opval); }
1970
1971     break;
1972
1973   case 280:
1974 #line 1406 "perly.y"
1975     {
1976                           (yyval.opval) = op_append_elem(OP_LIST, (ps[-2].val.opval), (ps[0].val.opval));
1977                         }
1978
1979     break;
1980
1981   case 282:
1982 #line 1413 "perly.y"
1983     { parser->in_my = 0; (yyval.opval) = (ps[0].val.opval); }
1984
1985     break;
1986
1987   case 290:
1988 #line 1430 "perly.y"
1989     { (yyval.opval) = newCVREF((ps[-1].val.ival),(ps[0].val.opval)); }
1990
1991     break;
1992
1993   case 291:
1994 #line 1434 "perly.y"
1995     { (yyval.opval) = newSVREF((ps[0].val.opval)); }
1996
1997     break;
1998
1999   case 292:
2000 #line 1438 "perly.y"
2001     { (yyval.opval) = newAVREF((ps[0].val.opval));
2002                           if ((yyval.opval)) (yyval.opval)->op_private |= (ps[-1].val.ival);
2003                         }
2004
2005     break;
2006
2007   case 293:
2008 #line 1444 "perly.y"
2009     { (yyval.opval) = newHVREF((ps[0].val.opval));
2010                           if ((yyval.opval)) (yyval.opval)->op_private |= (ps[-1].val.ival);
2011                         }
2012
2013     break;
2014
2015   case 294:
2016 #line 1450 "perly.y"
2017     { (yyval.opval) = newAVREF((ps[0].val.opval)); }
2018
2019     break;
2020
2021   case 295:
2022 #line 1452 "perly.y"
2023     { (yyval.opval) = newAVREF((ps[-3].val.opval)); }
2024
2025     break;
2026
2027   case 296:
2028 #line 1456 "perly.y"
2029     { (yyval.opval) = newGVREF(0,(ps[0].val.opval)); }
2030
2031     break;
2032
2033   case 298:
2034 #line 1461 "perly.y"
2035     { (yyval.opval) = newAVREF((ps[-2].val.opval)); }
2036
2037     break;
2038
2039   case 300:
2040 #line 1466 "perly.y"
2041     { (yyval.opval) = newHVREF((ps[-2].val.opval)); }
2042
2043     break;
2044
2045   case 302:
2046 #line 1471 "perly.y"
2047     { (yyval.opval) = newGVREF(0,(ps[-2].val.opval)); }
2048
2049     break;
2050
2051   case 303:
2052 #line 1476 "perly.y"
2053     { (yyval.opval) = scalar((ps[0].val.opval)); }
2054
2055     break;
2056
2057   case 304:
2058 #line 1478 "perly.y"
2059     { (yyval.opval) = scalar((ps[0].val.opval)); }
2060
2061     break;
2062
2063   case 305:
2064 #line 1480 "perly.y"
2065     { (yyval.opval) = op_scope((ps[0].val.opval)); }
2066
2067     break;
2068
2069   case 306:
2070 #line 1483 "perly.y"
2071     { (yyval.opval) = (ps[0].val.opval); }
2072
2073     break;
2074
2075
2076
2077       default: break;
2078
2079
2080 /* Generated from:
2081  * 2dfefce380093b4e965ea327b172cdeabe9d706bf879f0fea6e9388ee185bd32 perly.y
2082  * acf1cbfd2545faeaaa58b1cf0cf9d7f98b5be0752eb7a54528ef904a9e2e1ca7 regen_perly.pl
2083  * ex: set ro: */