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